Coding Agents Compared (October 2026): Claude Code, Codex, Cursor, Copilot and More

TL;DR

In 2026, coding agents are the fastest-moving category of developer tools. The question is no longer "can AI write code?" but "which agent should get this task, in which environment, with which permissions?"

This guide puts the most widely used agents of October 2026 side by side: Claude Code, OpenAI Codex, Cursor, GitHub Copilot, Google Antigravity, and on the open-source side OpenCode and Cline. We start with the concept and the three ways agents run (CLI, IDE, cloud), then cover a comparison table, choosing by scenario, security, workflow and cost control.

Note: Everything here was checked on October 24, 2026 against the vendors' official pricing pages, documentation and GitHub repositories. Prices are as of October 2026, excluding tax; plans in this space change every few months, so check the linked pricing page before you decide. We deliberately don't publish a benchmark ranking: results published by vendors and third parties use different benchmark versions and settings and contradict each other.

What is a coding agent, and how is it different from autocomplete?

The first generation of AI coding tools did autocomplete: as you typed, they predicted the next line or function and you pressed Tab. You decided which file to look at, when to run the tests and where the bug was.

A coding agent takes a task and drives it:

1. It searches the repository and reads the relevant files.
2. It makes a plan (most agents have a plan mode that shows it to you first).
3. It edits several files.
4. It runs build, lint and test commands in a terminal.
5. If the result is red, it reads why, fixes it and tries again.
6. When it's done, it hands you a diff, a commit or a pull request.

That cycle is the agent loop. How well an agent works doesn't depend on the model alone; the harness around it (tools, project instruction files, context management and the permission layer) matters at least as much. For the details, see Anatomy of an AI Harness.

In practice most products today do both: Cursor and Copilot still offer strong autocomplete, but the real investment is on the agent side.

Three ways to run: CLI, IDE and cloud

The same agent often runs on several "surfaces", so choosing the way of working first makes choosing a product easier.

Terminal (CLI) agents

The agent runs in a terminal session you open in your project folder; it reads and edits files directly on your machine and runs commands in your shell.

• Examples: Claude Code, Codex CLI, GitHub Copilot CLI, Antigravity CLI, OpenCode, Cline CLI.
• Strength: Editor-independent; Vim, JetBrains or VS Code, it doesn't matter. Easy to combine with scripts, git and CI. Non-interactive modes such as Claude Code's claude -p print mode or Codex's codex exec turn the same agent into a pipeline step.
• Weakness: To review changes visually you may need a separate diff tool or IDE extension.

IDE agents

The agent runs in a panel inside your editor; it sees open files, your selection and the problems list as context, and shows changes as line-by-line diffs.

• Examples: Cursor (its own editor), Copilot agent mode in VS Code, Visual Studio, JetBrains, Eclipse and Xcode, Cline, Antigravity IDE and extensions, and the Claude Code and Codex IDE extensions.
• Strength: Visual diffs, accept/reject buttons, and working in the same place as autocomplete. The lowest barrier for people new to agents.
• Weakness: Long-running work ties up your editor and your laptop.

Cloud and background agents

You hand off the task from a web UI, an issue, Slack or your phone; the agent clones the repository in an isolated virtual machine on the vendor's (or your own) infrastructure, installs dependencies, does the work and opens a PR.

• Examples: Claude Code cloud sessions and scheduled tasks, Codex Cloud, GitHub Copilot cloud agent, Cursor Cloud Agents, Antigravity's background multi-agent runs.
• Strength: Parallelism. You give several tasks to several agents at once and review the results as PRs; your laptop can be closed. Cursor's docs say cloud agents can build and test in their own VMs and that you can run as many in parallel as you want.
• Weakness: You need to configure the environment (dependencies, secrets, network access) properly once. The rhythm is "assign, then review" rather than a live conversation.

Rule of thumb: do exploration and design interactively in a CLI or IDE; hand well-defined, testable, independent work to cloud agents.

The leading agents in October 2026

Claude Code (Anthropic)

Anthropic's coding agent runs in the terminal, VS Code and JetBrains extensions, a desktop app, the web and mobile. Cloud sessions, scheduled tasks, a GitHub Actions integration and code review on GitHub/GitLab are part of the same product family.

• Models: The Claude family (Fable, Opus, Sonnet, Haiku), selected with aliases like opus, sonnet, haiku and fable. The terminal CLI, VS Code and JetBrains can also run through Amazon Bedrock, Google Cloud and Microsoft Foundry.
• Pricing (October 2026): Claude Code is not on the free plan. Pro is $20/month ($17/month billed annually); Max starts at $100/month with 5x or 20x Pro's usage. Alternatively, pay per token through the Claude Console. Team and Enterprise plans are separate.
• Permissions: Permission modes: default (ask), acceptEdits, plan, auto, dontAsk and bypassPermissions. In auto mode a second model (a classifier) reviews actions instead of you; per Anthropic, from v2.1.283 interactive terminal and VS Code sessions start in this mode. bypassPermissions runs everything without asking, and the docs recommend it only for isolated containers and VMs.
• Sandbox: An OS-level sandbox for Bash commands: Seatbelt on macOS, bubblewrap on Linux and WSL2. You decide which files and network domains commands can reach. Cloud sessions set network access to None, Trusted (the default: package registries, GitHub, cloud SDKs and other allowlisted domains), Full or a custom list.
• Extensibility: MCP, skills, hooks, subagents and plugins. Project instruction file: CLAUDE.md.
• Open source? No. The anthropics/claude-code repository on GitHub is public, but its license file says "All rights reserved".

OpenAI Codex

Codex is OpenAI's coding agent: Codex CLI, an IDE extension, the ChatGPT desktop app, the web (Codex Cloud), iOS, and Slack/GitHub integrations. OpenAI's docs now state that ChatGPT Work and Codex share the same usage limits.

• Models: OpenAI models. The docs recommend GPT-6.1 Sol for complex coding and agentic work, GPT-6 Astra for the hardest end-to-end work and GPT-6 Luna for clear, repeatable tasks. GPT-5.5 was retired from Codex with ChatGPT sign-in on October 14, 2026 (API key use was not affected).
• Pricing (October 2026): Codex isn't sold separately; it's part of ChatGPT plans. Free ($0) and Go ($8) get GPT-6 Luna in the desktop app, subject to rollout. Plus ($20/month) includes Codex on the web, CLI, IDE and iOS, cloud integrations such as automatic code review, and GPT-6.1 Sol. Pro plans are $100, $200 or $500/month. Business is $20/user/month (annual, 2+ users; $25 monthly). With an API key, the CLI, SDK and IDE extension work but cloud features don't, and you pay API rates.
• Permissions and sandbox: Two layers: the sandbox mode (read-only, workspace-write, danger-full-access) defines what's technically reachable, and the approval policy (on-request, never, etc.) defines when Codex must ask. Per OpenAI, locally the network is off by default and writes are limited to the workspace, with OS-level sandboxing on macOS, Linux and Windows. Codex Cloud tasks run in isolated, OpenAI-managed containers.
• Extensibility: MCP, skills and plugins, hooks, subagents. Project instruction file: AGENTS.md (plus AGENTS.override.md).
• Open source? Codex CLI, yes: the openai/codex repository is Apache-2.0. The cloud service and models are not.

Cursor

Cursor is an agent-first editor based on VS Code, with Cursor CLI, Cloud Agents you can manage from the web and iOS, automations and Bugbot code review. SpaceX announced in June 2026 that it would acquire Anysphere, the company behind Cursor, and Cursor's blog says the acquisition closed on August 14, 2026. Cursor is now sold as part of The X Subscription (one subscription for Grok, Cursor and X).

• Models: The plan's usage pool covers Cursor's own models (Grok 4.7, 4.6, 4.5 and Composer 2.5). Anthropic, OpenAI and Google models are available on Premium and above at API list price, paid from prepaid credit.
• Pricing (October 2026): Free $0 (limited), Plus $8/month (Cursor's own models only; no Cloud Agents or third-party models), Premium $30/month (4x Plus usage, Cloud Agents, automations, Bugbot), Super $100/month (15x), Ultra $200/month (50x). Teams seats are $30, $100 or $200. The usage pool refreshes weekly. Per Cursor, users on legacy Pro/Pro+/Ultra plans keep their existing terms.
• Permissions: Run Modes: Auto-review (what Cursor recommends for most people: allowlisted calls run, shell commands run in a sandbox when possible, everything else goes to a classifier), Allowlist, and Run Everything (every tool call runs without asking). Cloud Agents run in isolated VMs.
• Extensibility: MCP, skills, hooks, subagents, rules (.cursor/rules) and AGENTS.md.
• Open source? No.

GitHub Copilot

Copilot is now far beyond autocomplete: agent mode in VS Code, Visual Studio, JetBrains, Eclipse and Xcode, Copilot CLI in the terminal, the Copilot cloud agent (formerly the coding agent) that goes from issue to PR on GitHub.com, and automatic code review.

• Models: The widest model choice here. The plans page lists models from Anthropic (Claude Fable, Opus, Sonnet, Haiku), OpenAI (GPT-5.x and GPT-6 families), Google (Gemini), xAI (Grok), Microsoft and Kimi. Pro+ and Max can delegate tasks directly to Claude and Codex agents, as a preview.
• Pricing (October 2026): Free $0 (limited chat and agent use; CLI and agent mode included, no cloud agent), Pro $10/month, Pro+ $39/month, Max $100/month. Agent mode, code review, the cloud agent and Copilot CLI spend GitHub AI Credits; per GitHub's plans page, total monthly credits are worth $15 on Pro, $70 on Pro+ and $200 on Max (base credits plus a variable "flex" allotment). Paid plans can buy additional credits. For organizations, Business is $19 per seat per month (1,900 AI credits per user) and Enterprise $39 per seat per month (3,900 credits; requires GitHub Enterprise Cloud). GitHub announced that all plans moved from request-based "premium requests" to this token-based system on June 1, 2026; on paid plans, code completions and next edit suggestions are not billed in AI credits.
• Permissions and local sandbox: In VS Code, Copilot sessions have permission levels: Manual (asks according to your approval settings), Assisted (experimental; an LLM judge evaluates each tool call and asks you when it doesn't approve), Allow all, and Autopilot (auto-approves all tools and keeps going until the task is done). Terminal commands need approval by default; per-command rules can auto-approve safe ones. VS Code's agent sandbox uses Seatbelt on macOS and bubblewrap on Linux and WSL2 and must be turned on explicitly; per Microsoft, even with the sandbox on, outbound network access is not blocked by default and needs separate configuration. Copilot CLI has "trusted directories", --allow-tool / --deny-tool / --allow-all-tools options and optional local sandboxing; cloud sandboxes are in public preview.
• Security: The cloud agent has the most thoroughly documented protections: only users with write access can trigger it; it can push only to its own copilot/ branch; it can't approve or merge its PRs; GitHub Actions workflows don't run by default until a human approves; internet access is restricted by a firewall; hidden text such as HTML comments in issues is filtered out before it reaches the agent. Generated code is checked with CodeQL, secret scanning and the GitHub Advisory Database.
• Extensibility: MCP, agent skills, hooks, custom agents and custom instructions.
• Open source? No; Copilot CLI ships under its own license.

Google Antigravity (and what happened to Gemini CLI)

On May 19, 2026 Google announced it was moving Gemini CLI into Antigravity. Antigravity consists of a desktop app (Antigravity 2.0), an IDE, IDE extensions (VS Code, JetBrains, Visual Studio, Zed, Xcode), Antigravity CLI and a Python SDK. Per Google, the CLI is written in Go, can orchestrate multiple agents in the background, and shares its harness with the desktop app.

• What happened to Gemini CLI? Gemini CLI and the Gemini Code Assist IDE extensions stopped serving requests for Google AI Pro/Ultra subscribers and free Gemini Code Assist users on June 18, 2026. They keep working for organizations on Gemini Code Assist Standard/Enterprise licenses and for paid API key users. Gemini CLI's Apache-2.0 repository is still active on GitHub. Antigravity CLI, however, is not open source: the official google-antigravity/antigravity-cli repository contains only a README, a CHANGELOG and examples, with no source code and no license file, and installation uses a prebuilt binary. Google itself says Antigravity CLI doesn't have 1:1 feature parity at launch.
• Models: Gemini models; the Antigravity site announces Gemini 4 Argon for Google AI Pro and Ultra users.
• Pricing (October 2026): The individual plan is $0 (basic weekly limits). Google AI Pro and Ultra subscriptions add higher limits and a flexible AI credit pool. Organizations go through Google Cloud; Gemini Enterprise Standard/Plus start at $30/seat/month, and there's a consumption-based API option.
• Sandbox: The terminal sandbox is on by default: kernel namespaces on Linux, Seatbelt on macOS. Per Google, sensitive files such as ~/.ssh and .env are blocked and network access is limited to domains you approve. Permission presets: Request Review, Default, Auto (Preview) and Turbo (sandbox off, everything runs without asking).
• Extensibility: MCP, agent skills, rules, hooks, custom subagents and plugins.

Open-source options: OpenCode and Cline

If you don't want to be tied to one model vendor, or want to use your own API key or a local model, two big open-source projects stand out:

• OpenCode: MIT-licensed, with a terminal UI, a desktop app and a web UI. With more than 220,000 GitHub stars as of October 2026, it's the most-starred repository in this list. It connects to different providers with API keys or OAuth. Permissions are ordered allow / ask / deny rules (the last matching rule wins). It supports agents, skills, MCP and plugins; hooks are written through the plugin API (they intercept live operations). We found no OS-level sandbox page in its docs; it appears to rely on permission rules and OpenCode's "policies" layer, so run it in a container if you need a sandbox.
• Cline: Apache-2.0-licensed, available as an IDE extension, CLI, desktop app, SDK and cloud agents. Besides providers like Anthropic, OpenAI, Gemini, DeepSeek, Qwen and OpenRouter, it supports local models via Ollama and LM Studio, and can even use a Claude Code subscription or an OpenAI Codex sign-in as a provider. It has a Plan & Act mode, checkpoints, auto-approve settings, MCP, skills, hooks and subagents.

The open-source agents themselves are free, but you pay the model's token costs directly to the provider. Under heavy use that can cost more than a flat-rate subscription.

Comparison tables

The two tables below include only what we verified in official sources. "—" doesn't mean the feature is missing, only that we couldn't verify it.

Interface, models and pricing (October 2026)

Security and extensibility

Portability note: Skills (SKILL.md), MCP servers and AGENTS.md-style instruction files now exist in almost every agent. Invest in your setup once and switching agents is far cheaper than it used to be. See the Claude Skills Guide and the MCP Server Catalog.

Choosing by scenario

There is no single "best agent". The pairings below are a starting point; the final call should come from a one-week trial on your own repository with your own tasks.

• You live in the terminal and want automation and CI: Claude Code or Codex CLI. Both have non-interactive modes, detailed permission/sandbox settings and GitHub Actions integrations.
• You want the agent inside your editor with visual diffs: Cursor, or Copilot agent mode in VS Code. If you're new to agents, this is the lowest learning curve.
• Your team is already on GitHub and works issue → PR: Copilot cloud agent. Branch, approval and workflow limits plug into GitHub's own rules (branch protection, rulesets).
• You already pay for ChatGPT: Codex is included in Plus; you can start without another subscription.
• You already pay for Claude: Claude Code is included in Pro.
• You want to try many models under one subscription: GitHub Copilot offers the widest model list; in Cursor, third-party models are billed separately at API price.
• You're in Google's ecosystem (Google AI Pro/Ultra, Google Cloud): Antigravity. If your organization still has a Gemini Code Assist license, Gemini CLI keeps working.
• Your code must not leave, or you want your own model: OpenCode or Cline with your own provider or a local model (Cline supports Ollama and LM Studio). If you need cloud agents, Claude Code's self-hosted environments and Cursor's self-hosted runtime options exist; evaluate them against your organization's policy.
• Very tight budget: Copilot Free, Antigravity's individual plan and Cursor Free let you start for free with limits. Small models with open-source agents are another option, but in agentic work a weaker model usually means more turns and more mistakes.

Security: prompt injection, sandboxing and secrets

A coding agent is a program that reads files, runs commands and can reach the network with your user account. Think about security in three layers.

1. Prompt injection

Prompt injection means instructions hidden in content the agent reads: a README, an issue comment, a dependency's docs, a web page, or an MCP tool's output. The model can't always tell "the user's instruction" from "an instruction inside the data it read".

The risk grows when three things come together: the agent reads untrusted content, can access secrets, and can send data out (network, git push, an MCP tool). Cutting at least one of the three is the most effective defense. Examples:

• GitHub filters hidden characters and HTML comments in issues and comments before they reach the Copilot cloud agent, and restricts the agent's internet access with a firewall.
• Claude Code cloud sessions default to the Trusted network level: only package registries and allowlisted domains are reachable.
• Per OpenAI, Codex runs locally with network access off by default.

2. Sandboxing and permissions

An agent sandbox limits, at the operating-system level, what the agent's commands can touch. Permission rules decide which actions run without asking and which need approval. One doesn't replace the other.

• Start from the defaults. "Allow everything" modes (Claude Code bypassPermissions, Codex danger-full-access, Cursor Run Everything, Antigravity Turbo) only make sense inside an isolated container or VM.
• Classifier-based modes (Claude Code auto mode, Cursor Auto-review, Codex auto-review) reduce approval fatigue but don't replace human review.
• Explicitly deny destructive commands: git push, rm -rf, scripts that connect to production databases.
• Use branch protection. A PR produced by an agent shouldn't be merged without human approval. Copilot cloud agent enforces this by default; for other agents, your repository settings have to.

3. Secrets

• Deny reads of files like .env, ~/.ssh and cloud credentials (in Claude Code, deny rules such as Read(./.env); Antigravity blocks these in its sandbox by default).
• Don't give cloud agents production keys; use short-lived, narrowly scoped test keys where possible. The best pattern here is the network secrets feature in Codex Cloud and Claude Code cloud environments: per OpenAI, in Codex Cloud environment variables are passed directly to programs, while for network secrets programs only see a placeholder and a proxy substitutes the real value only on HTTPS requests to the domains you allow, so the raw credential never sits in a local process or file. Claude Code's cloud environments similarly use a proxy that attaches secrets only to requests for the hosts you list. If a program doesn't need to read a value directly, prefer this over an environment variable.
• Transcripts and logs are a leak surface too: anything the agent reads can end up in the session record.

Practical workflow tips

• Start from a clean git state. Start the agent on a committed working tree before every task; if you don't like the result, reverting is one command. Use git worktrees for parallel work.
• Invest in your instruction file. Put build/test commands, code style and folders not to touch in CLAUDE.md or AGENTS.md. Keep it short; move long, rarely needed instructions into skills.
• Plan first, then code. For larger work, start the agent in plan mode, read and fix the plan, then let it implement.
• Define "done". A verifiable criterion such as "tests green, linter clean, no new dependencies" helps the agent end the loop in the right place.
• Keep tasks small. Go module by module instead of "refactor the whole app". Small diffs give better results and are easier to review.
• Review agent output like a PR. Look specifically for loosened tests, unexpected files and new dependencies.
• Give deterministic checks to hooks. Use hooks for formatting, linting and blocked-command checks instead of relying on the model to remember.
• Manage context. Clear the session when a task is done, compact long sessions, and hand large investigations to a subagent so the main context stays lean. See Context Engineering.

Cost control

The main cost driver in coding agents is the context sent to the model again on every turn: instruction files, tool definitions, files read and command outputs. The longer a session runs, the more each turn costs.

A realistic scale: Anthropic puts the average Claude Code cost in enterprise deployments at about $13 per developer per active day and $150–250 per developer per month, with costs staying below $30 per active day for 90% of users. That's Anthropic's own data, measured at API prices; on subscription plans, usage is subject to limits instead.

Subscription or pay per token?

• Subscriptions (Claude Pro/Max, ChatGPT Plus/Pro, Cursor, Copilot) make costs predictable, but you'll hit limits. Codex uses five-hour windows on Plus and Business (per OpenAI, Pro plans currently have no five-hour limit), Cursor a weekly pool, Copilot monthly AI Credits. Codex's docs note that cloud tasks may use more of your allowance than local messages.
• Pay per token (API keys, OpenCode/Cline with your own provider, third-party models in Cursor) is flexible but can turn into a surprise bill if you don't set limits.

Concrete steps:

• Watch your usage. /usage in Claude Code, /usage and /credits in Antigravity CLI; the usage dashboards in your Codex, Cursor and Copilot account settings.
• Cap CI runs. In Claude Code print mode, --max-turns limits the number of turns and --max-budget-usd the estimated spend. Cursor lets you set spending caps for third-party models; Claude Team/Enterprise support per-user or organization spend limits.
• Match the model to the job. Not every task needs the strongest model. OpenAI recommends Luna for clear, repeatable tasks; in Claude Code, Sonnet for daily work and Opus or Fable for the hardest tasks.
• Shrink the context. Disable MCP servers you don't use, filter large logs and test output, clear the session between tasks. More in Token Reduction Techniques.
• Tune reasoning effort. Higher thinking levels mean more tokens; start low for simple tasks.

Further reading

• Coding Agent — the short definition.
• Agent Harness and Agent Loop — the layer that makes an agent an agent.
• Agent Sandbox, Prompt Injection, Human-in-the-loop — the security side.
• MCP, Agent Skills, Agent Hooks, Subagent — extension points.
• Anatomy of an AI Harness, Claude Skills Guide, MCP Server Catalog, Token Reduction Techniques.

Sources

All sources accessed on October 24, 2026.

• Anthropic: Claude pricing, Claude Code overview, Permission modes, Sandboxing, Cloud environments, Manage costs, CLI reference, Model configuration
• OpenAI: Codex pricing, Agent approvals & security, Models, AGENTS.md, Cloud environments, openai/codex repository
• Cursor: Pricing, Models & Pricing, Run Modes, Cloud Agents; CNBC: SpaceX to acquire Cursor, Cursor blog: Cursor is now a part of SpaceX
• GitHub: Copilot plans, Copilot on GitHub.com, Cloud agent risks and mitigations, Copilot plans (docs), Billing for organizations and enterprises, GitHub blog: moving to usage-based billing, About Copilot CLI, Cloud and local sandboxes, VS Code: AI security, VS Code: agent sandboxing
• Google: Transitioning Gemini CLI to Antigravity CLI, Antigravity pricing, Terminal sandbox, gemini-cli repository, antigravity-cli repository
• Open source: OpenCode docs, OpenCode permissions, OpenCode policies, OpenCode plugin API, anomalyco/opencode repository, Cline docs, cline/cline repository

Frequently asked questions

Is Claude Code or Cursor better?

There is no single right answer; it depends on how you work. If you live in the terminal and want scripting and CI automation, Claude Code fits naturally; if you want the agent inside an editor with visual diffs and tab completion, Cursor does. Trying both on your own repository with the same tasks for a week tells you more than any benchmark table.

Is there a free coding agent?

As of October 2026, GitHub Copilot Free (limited agent mode and CLI), Google Antigravity's individual plan and Cursor Free offer limited free use; Codex on the Free plan is limited and rolling out per OpenAI. Claude Code is not included in Claude's free plan. The open-source OpenCode and Cline are free, but you pay separately for the model API you connect.

What is the difference between a coding agent and autocomplete?

Autocomplete suggests the next line while you type; you stay in control. A coding agent takes a task, reads and edits files itself, runs commands and tests, keeps looping until it can verify the result, and hands you a diff or PR.

Has Gemini CLI been shut down?

For individual users, yes: according to Google, Gemini CLI stopped serving Google AI Pro/Ultra and free Gemini Code Assist users on June 18, 2026 and was replaced by Antigravity CLI. It keeps working for organizations on Gemini Code Assist Standard/Enterprise licenses and for paid API key users.

Are coding agents safe, and how do I protect my code and secrets?

Stay on the default permission mode, turn the sandbox on, limit network access to allowed domains and deny reads of files like .env. The biggest risk is prompt injection: an issue or web page the agent reads can carry hidden instructions. A human should review every change before it is merged.

Which coding agent is the cheapest?

The lowest paid list prices are GitHub Copilot Pro ($10/month) and Cursor Plus ($8/month, Cursor's own models only); ChatGPT Plus and Claude Pro are $20/month. Real cost depends on usage limits and the model, so measure your own workload for a month before deciding. Prices are as of October 2026.

Can I use several coding agents on the same project?

Yes. Most agents support AGENTS.md-style project instruction files, MCP servers and SKILL.md-style skills, so much of your setup is portable. GitHub Copilot also offers delegating tasks directly to Claude and Codex agents on its Pro+ and Max plans, as a preview.