What is an IDE?
An IDE (integrated development environment) is a desktop application that combines a code editor, language tooling, a debugger, build and test runners and version control around one person editing files. Everything in it assumes a human is at the keyboard: the cursor, the open tabs, the breakpoints, the refactoring menu.
Modern IDEs and code editors also ship AI features: inline completions while you type, a chat panel that knows the open file, and often an agent mode that can edit several files in the open project. The AI is powerful, but it is added to a tool designed for one person working on one thing at a time.
What is an ADE?
An ADE (agentic development environment) is a desktop application built for directing AI coding agents: it gives each task its own workspace, runs several agents at once, and puts their chat, terminals, browser and diffs in one place. The full definition lives in What is an ADE?.
Tallos is an ADE for macOS and Windows. It runs the agent CLIs you already use — Claude Code, Codex, Gemini CLI, OpenCode, GitHub Copilot and others — with your existing subscriptions and API keys. If you are new to the agents themselves, start with What are AI coding agents?.
- Workspaces: each task gets its own working copy of the repo on its own branch (a git worktree).
- Chat and terminal: supported agents open in a chat view; one switch shows the raw terminal.
- Browser: a real browser per workspace to check what the agent built.
- Diff review: read every change, comment on lines and send the notes back to the agent.
- Squads: a leader agent that splits work across member agents and reports back.
How is an ADE different from an IDE?
The core difference is the unit of work: an IDE is organized around the files you edit, an ADE around the tasks agents run. Everything else follows from that.
| Dimension | IDE | ADE (Tallos) |
|---|---|---|
| Unit of work | The file or project you have open | A task, with its own workspace and branch |
| Who types the code | You, with AI suggestions and edits | Agents; you step in with the built-in editor when needed |
| Parallelism | One working copy; usually one agent session at a time | Several agents at once, each on its own task |
| Isolation | Parallel work needs manual branches or extra clones | A separate git worktree per task, created for you |
| Review flow | Accept inline edits as they happen, then commit | Read the full diff per workspace, comment on lines, send notes back |
| Where AI lives | Sidebar, inline completions, agent mode inside the editor | The agent CLIs themselves (Claude Code, Codex, Gemini CLI…) |
| Language tooling | Deep: debugger, refactorings, language servers, extensions | Lighter: an editor for hand edits; run type-checkers and linters in a terminal |
| Best at | Writing, reading and debugging code by hand | Delegating, running and reviewing many agent tasks |
Notice what the table does not say: it does not say one is better. An IDE is the best place to think through code yourself. An ADE is the best place to run and supervise agents. They answer different questions.
When is an IDE the right tool?
An IDE is the right tool whenever the work is faster to do than to describe, or needs tooling that lives inside the editor.
- Debugging: stepping through code with breakpoints and watching variables.
- Language-aware refactors: rename a symbol across a project, extract a function, move a module.
- Reading and learning: building a mental model of an unfamiliar codebase.
- Small edits: a one-line fix you can type before you finish writing the prompt.
- Specialized toolchains: projects that depend on IDE plugins, visual designers or device tooling.
When is an ADE the right tool?
An ADE is the right tool when agents are doing most of the typing and you are deciding what to build and what to accept.
- Several tasks at once: a bug fix, a test sweep and a small feature, each with its own agent. See how to run AI agents in parallel.
- Comparing agents: the same task given to Claude Code and Codex, then the better diff kept.
- Long-running agent work: tasks you start, leave and come back to review.
- Review before merge: every change read as a diff and sent back with line comments when it needs work.
- Agent teams: a leader that divides the work and a reviewer that checks it, with squads.
Run your agents side by side, each in its own workspace.
Why does isolation matter so much in an ADE?
Isolation matters because two agents editing the same working copy will overwrite each other's files. In an IDE this rarely comes up: one person, one checkout. In an ADE it is the default situation, so Tallos creates a separate parallel workspace — a real git worktree on its own branch — for each task.
How do I use an ADE and an IDE together?
Use the ADE to start, run and review agent tasks, and open the same folder in your IDE whenever you want to take the wheel. Each Tallos workspace is a real git worktree on disk, so any editor can open it.
- 1
Create a task in Tallos
Name it, pick the branch to start from and choose the agent. Tallos creates the workspace.
- 2
Let the agent work
Watch it in the chat view or the terminal. Start other tasks in other workspaces meanwhile.
- 3
Review the diff
Read the changes in Tallos, comment on lines and send the notes back to the agent.
- 4
Open it in your IDE when needed
For a debugging session or a careful refactor, open the workspace folder in your IDE.
- 5
Merge like any branch
Commit, push and open a pull request from the workspace.
More on the review step in diff review, and on the underlying mechanics in git worktrees for AI agents.
Frequently asked questions
Does an ADE replace my IDE?
No. An ADE is built for running and reviewing AI agents, while an IDE is built for editing and debugging code by hand. Most developers keep both and move between them.
What does ADE stand for?
ADE stands for agentic development environment: a desktop app built around AI coding agents instead of around a single person editing files. See the glossary for related terms.
Does Tallos have a code editor?
Yes. Tallos includes an editor for hand edits, and you can drag a file into an agent prompt to give it exact context. For heavy debugging or language-aware refactors, an IDE is still the better tool.
Can I open a Tallos workspace in my IDE?
Yes. Each workspace is a real git worktree on its own branch, stored as a normal folder on disk, so you can open it in any editor or IDE.
My IDE already has an agent mode. Do I need an ADE?
If you run one agent on one task at a time, your IDE's agent mode may be enough. An ADE pays off when you run several agents at once, compare agents on the same task or want a review step before anything merges.
Which agents can I run in Tallos?
Claude Code, Codex, Gemini CLI, OpenCode, Grok CLI, Qwen Code and MiMo Code can be installed and signed in from the Connections page. GitHub Copilot and many other agent CLIs are detected automatically, and any CLI agent can be added as a custom agent.
Which platforms does Tallos run on?
Tallos is a desktop app for macOS 13 or later (Apple Silicon and Intel) and Windows 10 or later.
