Home โ€บ Blog โ€บ Agentic Developer Workbenches
Harness Engineering ยท Product Case Studies #12โ€“#15 ยท Snapshot: September 2026 ๐Ÿ› ๏ธ

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.

How to read this: part of the product case-study lens (see also the platform comparison). Facts come from each vendor's announcements and documentation, checked in September 2026 and linked in References. These products ship weekly; features, names and default models change fast. Internal implementations aren't public, and diagrams simplify.

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:

โ–ถ The common workbench stack A request flows through the layers; press play.

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.

Oct 2025Cursor 2.0: parallel agents in git worktrees or remote machines
29 Apr 2026Cursor SDK: the same runtime, harness and models from TypeScript
29 Jun 2026native iOS app: cloud agents, remote control, voice, PR merges
ComposerCursor's own agentic coding models, alongside frontier models

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.

CLI = enginethe Copilot CLI runtime runs the agent loop
2 Jun 2026Copilot SDK generally available
6 languagesSDK: TypeScript, Python, Go, .NET, Rust, Java
JSON-RPCSDKs drive the CLI in server mode

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.

19 May 2026Antigravity 2.0 at Google I/O
agynew CLI, retiring Gemini CLI
Gemini 3.5 Flashdefault model
Managed Agents APIplus scheduled background tasks and native voice

Antigravity 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.

2 Jun 2026Windsurf becomes Devin Desktop
Devin LocalRust-rewritten local agent; replaces Cascade; ~30% more token-efficient
ACPruns Claude Code, Codex, OpenCode and any ACP agent
Spacesshared context per project, persisting across sessions

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

โ–ถ Pick a layer; compare all four Or pick a product to see its whole stack.

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:

โ–ถ The same task, two execution environments
Local agentCloud agent
Runs onYour machineIsolated VM or container per task
EnvironmentYour tools, credentials, servicesCloned repo; dependencies installed per task (snapshots speed this up)
SafetyPermissions and sandbox policies on your machineIsolation and firewalled networking by default
ParallelismA few, via worktreesMany; limited by budget and review capacity
OutputEdits in your working copyA 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:

โ–ถ 40 tasks, N agents, R reviewers Simulated; assumptions in the script below.
"""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:

โ–ถ Who talks to whom Press play to animate messages.

10 Key Architectural Differences

Five design axes separate the four. Positions are our reading of each product's documented design, not a score:

โ–ถ Design spectrums Hover a dot.
Hover a product on any axis.
The workbenches in one paragraph
In September 2026 the four leading coding workbenches share one architecture โ€” surfaces, harness, context, models, tools, local and cloud execution, parallel agents, Git/CI, observability and human control โ€” and differ in where they put the centre of gravity. Cursor keeps the IDE at the centre and pushes its harness outward to web, mobile, CLI and SDK. GitHub Copilot makes one runtime (the CLI) the engine behind every surface and wires it into GitHub itself. Google's Antigravity 2.0 is an agent manager first, co-optimized with Gemini and Google's cloud and mobile stack. Devin Desktop is a command center for fleets of agents โ€” its own and anyone else's over ACP. For users, the practical limit is no longer how many agents can run, but how fast humans can review what they produce.

Next: Harness Engineering Across Real-World Contexts: One Pattern, Nine Domains โ†’

โš ๏ธ Notes

Corrections and updates to the source infographic: (1) model layers are out of date โ€” it lists "GPT-5 / 4.1, Claude 4, Gemini 2.5" for Cursor and Copilot; in September 2026 Cursor also runs its own Composer models alongside current frontier models, and Copilot is multi-model rather than "powered by OpenAI models"; (2) Antigravity's models โ€” it lists "Gemini 3.5 / Pro"; the default is Gemini 3.5 Flash, and Gemini 3.5 Pro had not been released as of late August 2026; it also omits that the 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.

๐Ÿ”— References