Agentic Developer Workbenches: Cursor, GitHub Copilot, Google Antigravity 2.0 and Devin Desktop Compared
The coding tool has become an agent workbench: one surface where developers launch, supervise and merge the work of many agents running locally and in the cloud. This visual deep dive compares the four leading workbenches as of September 2026 โ how each combines an IDE or command center, an agent harness, context, models, tools, execution environments, parallel agents, Git and CI, observability and human control โ with an interactive architecture explorer, protocol animations and a runnable model of where parallel-agent speedups go.
01 Eleven Architectural Layers Common to All Four
Despite different branding, all four workbenches assemble the same stack. Hover a layer to see what it does โ the same numbering is used throughout the article:
02 Cursor โ the IDE-Native Agentic Development Environment
Shape: an AI-first IDE (VS Code-based) whose agent harness now reaches every surface โ desktop, web, iOS, CLI, SDK and external triggers.
Cursor's agent harness combines instructions, tools and a model with model-specific orchestration, planning and task decomposition, tool/MCP integration and error handling. Context comes from a semantic + keyword codebase index, project memory, web search and docs, and multi-repo support. Agents run locally (editing files and running commands on your machine) or as Cloud Agents: Cursor clones the repository into an isolated VM, installs dependencies, works on a separate branch and pushes changes back as a pull request. A coordinator agent can plan and delegate to many agents in parallel with shared project context, and external triggers (Slack, GitHub, Linear) can start agents without opening the IDE.
03 GitHub Copilot โ an Agentic Coding Platform Across IDE, CLI and GitHub
Shape: one agent runtime โ the Copilot CLI โ behind every surface, deeply integrated with GitHub's issues, PRs and Actions.
The Copilot CLI runtime is the orchestrator: it runs the agentic tool-use loop, makes one or more model calls until done, manages sessions, enforces permissions and safety controls, and integrates MCP, plugins and hooks. The Copilot SDK doesn't contain inference itself โ it communicates with the CLI over JSON-RPC, so the Copilot app, the CLI and your own integration all share one foundation (GitHub has also described migrating that runtime to Rust). Agents run locally with file-system permissions and sandbox policies, or as the Copilot cloud agent in ephemeral, firewalled environments with cloned repositories that create branches and open PRs โ with GitHub-native issue integration, Actions checks and test results in the loop.
04 Google Antigravity 2.0 โ an Agent-First Development Platform
Shape: a standalone agent-management desktop app (not a VS Code fork), a CLI, an SDK and a managed agents API, optimized for Gemini and the Google ecosystem.
agynew CLI, retiring Gemini CLIAntigravity started (November 2025) as an agent-first IDE; version 2.0 put multi-agent orchestration at the centre: many agents working in parallel, custom subagent workflows, and tasks scheduled to run in the background. Its harness is co-optimized for Gemini, with goal and task planning, dynamic subagents, hooks and an event system, and asynchronous execution. Context spans repository and project memory, cross-project knowledge and web/docs, with persistent multimodal artifacts. Its distinctive layer is ecosystem integration: Google AI Studio, Android tooling (ADB, emulator) and Firebase for deployment and backends; enterprise deployment goes through the Gemini Enterprise Agent Platform.
05 Devin Desktop โ an Agent Command Center for Software Engineering
Shape: a command center that manages fleets of local and cloud agents โ including third-party agents over an open protocol โ with a full IDE underneath.
Cognition's Agent Command Center is a Kanban-style view to plan, delegate and monitor work, manage local and cloud agents, track PRs and progress, and handle conflicts and synthesis โ with the full IDE one click away for intervention. Spaces group related agents, sessions, PRs and files with shared memory, repository context and team knowledge. Devin Cloud agents run in isolated VMs from configured snapshots with a full development environment, terminal, browser and computer use, and long-running sessions that create and update PRs. Through the Agent Client Protocol (ACP) โ an open standard for editorโagent communication, analogous to LSP for language servers โ external agents run side by side with Devin.
06 Layer-by-Layer Explorer
07 Local Agents vs Cloud Agents
Every workbench now offers both. Local agents are fast and see your whole machine; cloud agents are isolated, parallel and keep working when your laptop is closed. Toggle and press play:
| Local agent | Cloud agent | |
|---|---|---|
| Runs on | Your machine | Isolated VM or container per task |
| Environment | Your tools, credentials, services | Cloned repo; dependencies installed per task (snapshots speed this up) |
| Safety | Permissions and sandbox policies on your machine | Isolation and firewalled networking by default |
| Parallelism | A few, via worktrees | Many; limited by budget and review capacity |
| Output | Edits in your working copy | A branch and a pull request |
08 Parallel Agents and the Review Bottleneck
All four let you run many agents at once โ worktrees, cloud VMs, subagents. But every change still needs review and merge, some fail review, and parallel branches sometimes conflict. Move the sliders:
"""Parallel coding agents: where does the speedup go?
All four workbenches let you run many agents at once (worktrees, cloud VMs, subagents). Throughput
is still bounded by what agents can't parallelize away: the human who reviews and merges their PRs,
and rework when parallel branches conflict or a change fails review. A small discrete simulation.
Assumptions (adjustable): 40 independent-ish tasks; an agent takes 20-60 min per task; a reviewer
needs 10 min per PR and one reviewer works through PRs one at a time; 20% of PRs fail review and
go back for another agent pass; each extra agent running concurrently adds 1.5 percentage points
of merge-conflict probability (conflicts cost a 15 min rebase by the agent). Standard library only.
"""
import heapq, random
TASKS, REVIEW_MIN, FAIL_P, CONFLICT_PER_AGENT = 40, 10, 0.20, 0.015
def simulate(agents, reviewers, seed=0):
rng = random.Random(seed)
queue = list(range(TASKS)); done = 0; t = 0.0
running = [] # (finish_time, task)
review_free = [0.0] * reviewers
for _ in range(min(agents, len(queue))):
heapq.heappush(running, (rng.uniform(20, 60), queue.pop()))
while done < TASKS:
t, task = heapq.heappop(running)
if rng.random() < CONFLICT_PER_AGENT * (agents - 1):
heapq.heappush(running, (t + 15, task)); continue # rebase, then resubmit
r = min(range(reviewers), key=lambda i: review_free[i])
start = max(t, review_free[r]); review_free[r] = start + REVIEW_MIN
if rng.random() < FAIL_P:
heapq.heappush(running, (review_free[r] + rng.uniform(10, 30), task)) # rework
else:
done += 1
if queue: heapq.heappush(running, (t + rng.uniform(20, 60), queue.pop()))
return max(t, max(review_free))
base = sum(simulate(1, 1, s) for s in range(30)) / 30
print(f"{TASKS} tasks; one agent + one reviewer finishes in {base / 60:.1f} h on average (30 runs)\n")
print(f" {'agents':>6} {'reviewers':>10} {'hours':>8} {'speedup':>9}")
for agents, reviewers in [(1, 1), (2, 1), (4, 1), (8, 1), (16, 1), (8, 2), (16, 2), (16, 4)]:
h = sum(simulate(agents, reviewers, s) for s in range(30)) / 30
print(f" {agents:>6} {reviewers:>10} {h / 60:>8.1f} {base / h:>8.1f}x")
print("\nPast a few agents, the reviewer - not the agents - sets the pace.")Output:
40 tasks; one agent + one reviewer finishes in 31.8 h on average (30 runs)
agents reviewers hours speedup
1 1 31.8 1.0x
2 1 16.0 2.0x
4 1 9.2 3.5x
8 1 9.0 3.5x
16 1 9.0 3.5x
8 2 5.3 6.0x
16 2 5.0 6.3x
16 4 3.4 9.3x
Past a few agents, the reviewer - not the agents - sets the pace.With one reviewer spending ten minutes per PR, four agents already saturate them: sixteen agents finish no sooner than four. Throughput comes back only with more review capacity โ or with cheaper review: better tests, automatic checks, agents that verify their own work and small, focused PRs. That is why every workbench invests in observability, diffs, test results and review tooling as much as in agents.
09 SDKs and Protocols: How Programs Drive the Agents
Each workbench exposes its harness to code โ but the plumbing differs. Pick one:
10 Key Architectural Differences
Five design axes separate the four. Positions are our reading of each product's documented design, not a score:
Next: Harness Engineering Across Real-World Contexts: One Pattern, Nine Domains โ
โ ๏ธ Notes
agy CLI retired Gemini CLI and that 2.0 added a Managed Agents API; (3) Copilot SDK โ generally available since 2 June 2026, in six languages, communicating with the Copilot CLI over JSON-RPC (the infographic shows JSON-RPC but not GA status or languages); (4) Devin Desktop โ worth adding that it replaced Windsurf on 2 June 2026 and that Devin Local replaced Cascade. The layer explorer, spectrum positions and animations are simplified; the parallel-agents simulation uses stated assumptions.