# What is an ADE (Agentic Development Environment)?

> An ADE (agentic development environment) is a desktop environment built for directing AI coding agents instead of typing every line yourself. It gives each task an isolated workspace, runs several agent CLIs side by side, tracks which ones need you, and puts diff review before anything is merged. Tallos is an ADE for macOS and Windows.

- Canonical: https://runtallos.com/what-is-an-ade
- Português: https://runtallos.com/pt/o-que-e-um-ade.md
- Updated: 2026-09-29

## Key facts

- ADE = agentic development environment
- Built around agents, workspaces and review, not a single editor buffer
- Every task gets its own git worktree in Tallos
- Works with the agent CLIs and subscriptions you already have
- Tallos runs on macOS 13+ and Windows 10+

## What is an ADE?

An **ADE (agentic development environment)** is a development environment that treats AI coding agents as the main workers and you as the person who directs and reviews them. Where an IDE is organized around files and a cursor, an ADE is organized around tasks, agents, isolated workspaces and review.

The term exists because the work changed. With [AI coding agents](https://runtallos.com/what-are-ai-coding-agents) like Claude Code, Codex or Gemini CLI, you describe an outcome and the agent reads the code, edits files, runs commands and tests. One agent is easy to manage in a terminal. Three, five or ten are not. An ADE is the layer that keeps that many agents organized, separated and reviewable.

> **Short definition** — An ADE is a desktop environment that runs multiple AI coding agents in parallel, each in its own isolated workspace, and gives you one place to watch, steer and review their work.

## Why do ADEs exist?

ADEs exist because agent CLIs made writing code cheaper than coordinating it. An agent can draft a feature in minutes. The slow part becomes everything around it: giving it a clean branch, keeping it from touching another agent's files, noticing when it is waiting for an answer, and reading the diff before it ships.

Without an ADE, developers solve this by hand: several terminal windows, a `git worktree add` per task, tmux panes, a notes file to remember which agent is doing what. It works for two agents. It falls apart at five. An ADE turns that manual setup into the default.

- **Isolation** — each task runs in its own checkout, so agents never overwrite each other.
- **Visibility** — you see which agent is working, which is done and which needs your answer.
- **Review** — every change lands as a diff you read, comment on and accept before it is merged.
- **Orchestration** — one agent can plan work and hand parts of it to others.

## What is the difference between an ADE and an IDE?

An IDE is built for one person editing code; an ADE is built for one person directing many agents that edit code. Both have a terminal, an editor and git. The difference is what sits at the center of the screen and what the tool assumes about who is typing.

**IDE (integrated development environment)**
- Centered on files, tabs and the cursor
- One working copy, one branch at a time
- AI shows up as autocomplete or a side-panel chat
- You write most of the code; the AI assists
- Switching tasks means stashing or switching branches

**ADE (agentic development environment)**
- Centered on tasks, agents and workspaces
- One isolated worktree and branch per task
- Full agent CLIs run side by side in their own terminals
- Agents write most of the code; you plan and review
- Switching tasks means clicking another workspace

|  | IDE | ADE |
| --- | --- | --- |
| Unit of work | A file or a project | A task with its own workspace |
| Parallel work | Manual (extra clones, stashes) | Built in (one worktree per task) |
| AI role | Assistant inside the editor | Several autonomous agents |
| Where you spend time | Writing and navigating code | Directing, answering, reviewing diffs |
| Review | Your own changes, before commit | Every agent's diff, before merge |
| Status | Build and test output | Which agent is working, done or waiting on you |

_IDE vs ADE at a glance. Most developers keep both._

An ADE does not replace your editor. Many people keep their IDE for deep manual work and use an ADE when agents do the typing. For a full breakdown, read [ADE vs IDE](https://runtallos.com/compare/ade-vs-ide).

## What does an ADE coordinate?

An ADE coordinates four things: agents, isolated workspaces, terminals and review. Each one solves a specific problem that shows up as soon as more than one agent is running.

1. **Agents** — The ADE launches agent CLIs such as Claude Code, Codex, Gemini CLI or OpenCode with the right working directory, and tracks each session's state: working, waiting for you, done or idle.
2. **Isolated workspaces** — Each task gets its own copy of the repository, usually a git worktree with its own branch and files on disk. Two agents can change the same file in two workspaces without conflict until you choose what to merge.
3. **Terminals** — Agents, dev servers and test runners each need a terminal. The ADE scopes terminals to the workspace they belong to and lets you split and watch several at once.
4. **Review** — The output of an agent is a diff. The ADE shows that diff against the starting point, lets you comment on lines and sends your notes back to the agent before anything is merged.

Good ADEs add context around those four: a browser per workspace to see what the agent built, links to the GitHub, GitLab, Linear or Jira item the task came from, and a way to schedule recurring agent work. See how isolation works in [parallel workspaces](https://runtallos.com/features/parallel-workspaces).

## What does it look like to work in an ADE?

Working in an ADE looks like managing a small team. You open a task, pick an agent, write what you want and move to the next task while the first one runs. When an agent needs an answer, it shows up as waiting. When it finishes, you read its diff, leave comments or accept it, and open a pull request.

> Try an ADE on your own repo. Tallos runs on macOS and Windows with the agents you already use. → https://runtallos.com/signup

## When do you need an ADE?

You need an ADE when you run more than one agent at a time, or when waiting for one agent has become the bottleneck. If you use a single agent occasionally, a terminal is enough.

- You already pay for Claude Code, Codex or another agent and keep several terminal windows open.
- You want two or three agents to try the same hard problem and keep the best result.
- Agents keep stepping on each other's changes, or you are tired of stashing to switch tasks.
- You want one agent to build and another to review before you look.
- You lose track of which agent is waiting for an answer.
- You want recurring work, such as dependency upgrades, to run on a schedule and wait for your review.

> **When you do not need one** — If you write most code by hand and use AI for autocomplete, a regular IDE is the right tool. An ADE pays off when agents do most of the typing and you do most of the deciding.

## How does Tallos implement an ADE?

Tallos is a desktop ADE for macOS 13+ (Apple Silicon and Intel) and Windows 10+. It runs the agent CLIs you already use, gives each task its own git worktree and keeps agents, terminals, browser and diffs in one window.

| ADE layer | How Tallos does it |
| --- | --- |
| Agents | Claude Code, Codex, Gemini CLI, GitHub Copilot CLI, OpenCode, Grok CLI, Qwen Code, MiMo Code and dozens more preconfigured; any agent CLI can run in a terminal |
| Setup | A Connections page installs supported agents with the vendor's own command, signs you in or stores an API key securely, and lists each agent's models |
| Isolation | Every task is a real git worktree with its own branch, files, terminals and browser tabs |
| Conversation | Supported agents open in a readable chat view by default; one switch shows the raw terminal |
| Status | Each session shows working, waiting on you, done or idle, and Tallos notifies you when an agent finishes |
| Review | A diff against the start point, line comments sent back to the agent as one batch, then commit, push and open a PR |
| Orchestration | Squads: a leader agent splits an objective across member agents, checks results and waits for you to accept or discard |
| Recurring work | Automations and scheduled squads run hourly, daily, on weekdays, weekly or on a custom schedule |
| Remote | Workspaces can run on another machine over SSH |


The orchestration layer is where Tallos goes past a set of terminals. A [squad](https://runtallos.com/features/squads) is a leader agent plus member agents, each member in its own worktree. Templates cover the common patterns: build + review, three attempts with the best one picked, or the leader dividing the work. Squads are bounded — 5 rounds and 4 members at once by default, up to 20 rounds and 12 members.

Tallos does not sell model access. It uses the subscriptions and API keys you already have with each agent vendor.

## What is an ADE not?

- **Not a model.** An ADE runs agents; the intelligence comes from the agent and the model you pick.
- **Not a git replacement.** In Tallos every workspace is a real git worktree. You can open a terminal and use plain git at any time.
- **Not a security sandbox.** A worktree isolates files from other tasks, not the agent from your machine. Tallos lets you switch agents from autonomous launches to manual permission prompts in Settings.
- **Not a substitute for review.** An ADE makes review faster and harder to skip. It does not make it optional.

Ready to go deeper? Read about [multi-agent development](https://runtallos.com/multi-agent-development), then learn [how to run agents in parallel](https://runtallos.com/run-ai-agents-in-parallel).

## Frequently asked questions

### What does ADE stand for in software development?

ADE stands for agentic development environment: a development environment built for directing AI coding agents, with isolated workspaces, agent terminals and diff review in one app.

### Is an ADE the same as an AI code editor?

No. An AI code editor adds AI to a traditional editor built around one working copy. An ADE is built around running several agents on several tasks at once, each in its own workspace, with review before merge.

### Do I need to stop using my IDE if I use an ADE?

No. Many developers keep their IDE for manual editing and use an ADE when agents do the work. In Tallos, every workspace is a normal git worktree, so any editor can open it.

### Which AI agents work in an ADE like Tallos?

Tallos preconfigures Claude Code, Codex, Gemini CLI, GitHub Copilot CLI, OpenCode, Grok CLI, Qwen Code, MiMo Code and many more, and any agent that runs as a CLI can run in a Tallos terminal.

### Does an ADE come with its own AI model?

Tallos does not. It uses the agent subscriptions and API keys you already have, so you keep your existing plans with each vendor.

### What platforms does Tallos run on?

Tallos is a desktop app for macOS 13 or later (Apple Silicon and Intel) and Windows 10 or later.

### Is an ADE only for professional developers?

No, but it assumes you will review what agents change. People building with AI for the first time get the most from an ADE when they use its review step and build + review squads.

---

**Run your agents in parallel with Tallos** — Claude Code, Codex, Gemini and 30+ agents — each in its own workspace, with squads, chat, terminals and review in one app. Uses the subscriptions you already have.

https://runtallos.com/signup (macOS 13+ · Windows 10+)