An AI dev agent platform takes a coding task, edits the code, runs commands and tests, and returns a pull request. As of November 2026, 12 are worth shortlisting: Claude Code, OpenAI Codex, GitHub Copilot, Cursor, Devin, Kiro, Google Antigravity, JetBrains Air, Factory, OpenHands, Cline and Aider. Most paid plans start at $10–$30 per developer per month.
Updated 13 November 2026. The right AI dev agent platform depends less on the model than on where your code may run, who reviews the output, and how you cap the bill. Review matters more than it looks: the November 2026 version of a Harvard study of 655 firms found that adopting coding agents raised lines of code per engineer by 44% and pull requests by 36%, but made pull-request review 56% longer, while resolved issues rose a not-quite-significant 14% (what that means for your roadmap). Looking for a platform to build an AI agent into your own product instead, such as Agentforce or Copilot Studio? Read build vs buy an AI agent.
We write this as a studio that builds production AI agents for regulated industries — and open-sourced Kite, an agent framework built on the rule that the LLM is an untrusted component. We judge coding agents by the same rule: what can it reach, what can it prove, and who signs off. This is not a framework guide — if you are building an agent into your product, read how to choose an AI agent framework in 2026. This post is about the AI agents for software development that write your code.
A code assistant suggests; a dev agent acts. Autocomplete and chat answer one prompt at a time and leave every edit to you. An agent runs a loop: read the repository, make a plan, edit several files, run the build and tests, read the errors, try again, and stop when the task is done or it is stuck. Gartner's 2026 Magic Quadrant for Enterprise AI Coding Agents (published May 20, 2026) defines the category in those terms — semiautonomous tools that turn human intent into multistep plans and then execute and verify them across code and tests — and names Anthropic, Cursor, GitHub and OpenAI as Leaders.
For a team, agents change who drafts whole tasks — which moves the bottleneck to review, testing and security.
IDE-embedded and agentic desktop apps keep the developer in the loop on every step: Cursor (now part of SpaceX, which completed its acquisition of Cursor's maker Anysphere in August 2026), Devin Desktop (Windsurf was renamed Devin Desktop by Cognition in June 2026), AWS's Kiro, which pushes a spec-first workflow — requirements, design and task list before code — Google Antigravity, and JetBrains Air, which runs several agents (Junie, Claude Agent, Codex, Copilot and any agent that speaks the Agent Client Protocol) side by side.
Terminal (CLI) agents run in your shell against your local checkout, with your tools, scripts and test suite. Claude Code and OpenAI's Codex CLI are the main ones; both also run in IDEs, desktop apps and the browser, and both can run headless in CI. Kiro, Devin, Factory, Antigravity and GitHub Copilot now ship CLIs too.
Cloud autonomous agents take a ticket and work in a remote, disposable environment, then open a pull request. GitHub's Copilot cloud agent (now documented as "Copilot in the cloud"), Claude Code cloud sessions, Codex Cloud, Devin and Cursor's cloud agents all work this way. Google is retiring Jules, its cloud agent: it turned read-only on November 11, 2026 and shuts down on December 31.
Open-source, self-hosted agents let you pick the model and keep execution on your infrastructure: OpenHands (MIT, any LLM, optional Docker sandbox), Cline (Apache 2.0, VS Code/JetBrains/CLI, approval on each step by default) and Aider (Apache 2.0, terminal, commits each change to git).
App builders such as Replit Agent target non-developers building apps from chat — a different job from working in an existing codebase.

Positioning as of 13 November 2026, taken from each vendor's own documentation, pricing page and changelog. We deliberately do not score or rank them; entry prices are monthly list prices and change often.
| Platform | Type | Where the code runs | Models | Entry paid plan (monthly) |
|---|---|---|---|---|
| Claude Code (Anthropic) | Terminal + IDE + desktop + web | Your machine (OS-level sandbox for shell commands), Anthropic-hosted cloud sessions or a self-hosted environment | Claude models, also via Amazon Bedrock, Google Cloud (formerly Vertex AI) or Microsoft Foundry | Claude Pro $20; Max $100; Ultra $200 |
| OpenAI Codex | CLI (open source) + IDE + desktop app + cloud | Local sandbox or Codex Cloud | OpenAI models; the CLI also has built-in Amazon Bedrock and Google Vertex AI providers | ChatGPT Plus $20; Pro from $100 |
| GitHub Copilot | IDE + CLI + cloud agent | Cloud sandbox (can span repos), GitHub Actions (59-minute cap per session) or a remote environment you connect | Multi-vendor, incl. Claude Fable 5.2 and Gemini 4 Carbon; BYOK | Pro $10; Pro+ $39; Business $19/seat |
| Cursor (SpaceX) | IDE + CLI + cloud agents | Locally, cloud VMs, or machines you manage | Grok and Cursor models in the plan; third-party models billed at API list price | Plus $8 (Grok only); Premium $30 |
| Devin / Devin Desktop (Cognition) | Cloud agent + desktop IDE + CLI | Cloud VMs, desktop, CLI | Cognition SWE-2 models plus frontier models from several providers | Pro $20; Max $200; Teams $80 + $40/seat |
| Kiro (AWS) | IDE + CLI + web, spec-driven | Local IDE and CLI; Kiro Web | Several providers, incl. Grok 4.7 (experimental) | Pro $20 (1,000 credits); extra credits $0.04 |
| Google Antigravity | Agent-first app + CLI + IDEs | Local app; business plans via Google Cloud | Gemini 4 models | Free for individuals; Business from $30/seat |
| JetBrains Air + Junie | Multi-agent environment in JetBrains IDEs, web, CLI | Local agents; cloud runs rolling out | Bring your own subscription, API key or base URL; JetBrains AI credits at API rates | Uses your existing agent or JetBrains AI subscription |
| Factory | "Droids" on desktop, CLI and SDK | Desktop app, CLI and SDK | Multiple providers; free plan with your own keys | Pro $20; Teams $60 + $40/seat |
| OpenHands | Open source, self-hosted | Your infra, optional Docker sandbox per conversation; optional cloud | Any LLM | Free (MIT) + your model bill |
| Cline | Open source, IDE + CLI | Your machine | Any provider you configure | Free (Apache 2.0) + your model bill |
| Aider | Open source, terminal | Your machine | OpenAI, Anthropic, Gemini, Bedrock, Vertex, Ollama, OpenRouter, OpenAI-compatible APIs | Free (Apache 2.0) + your model bill |
Two longer-running shifts are worth noting. AWS stops supporting the Amazon Q Developer IDE plugins on April 30, 2027 and points users to Kiro. And tool connectivity has standardised on open specs under the Linux Foundation's Agentic AI Foundation: Anthropic donated the Model Context Protocol in December 2025, when there were already more than 10,000 active public MCP servers, and on October 22, 2026 it donated the Agent Skills standard, which more than 70 agent platforms — including ChatGPT, Cursor, GitHub Copilot and VS Code — have adopted. Useful — and attack surface: every MCP server or skill you install is code with access to whatever the agent can reach.

The biggest November 2026 changes are a new top Anthropic coding model (Claude Fable 5.2, November 9), Google's Jules going read-only (November 11) ahead of its December 31 shutdown, and more agents landing in other vendors' tools: Copilot in JetBrains Air and Xcode, Grok 4.7 in Kiro. Every item below is checked on the vendor's own blog or changelog.
Late October set this up: GPT-6.1 Terra reached Codex on Plus, Pro, Business, Enterprise and Edu plans (Oct 26), Cursor released an Agent SDK (Oct 20), Cognition launched Devin Security (Oct 26), and Cursor posted a security notice about a malicious extension impersonating Anthropic's Claude Code in its VS Code extension marketplace (Oct 29) — a reminder to install agent extensions only from verified publishers.
For most developers, a $10–$30 per month plan (Copilot Pro, Claude Pro, ChatGPT Plus, Cursor Premium, Kiro Pro, Devin Pro) is enough to learn whether an agent fits your codebase. Heavy daily agent use usually ends in a $100–$200 tier or usage billing, so judge value by merged pull requests per dollar on your own repo, not by list price.
List prices on each vendor's pricing page, read 13 November 2026 (monthly billing unless noted):
| Platform | Free tier | Individual | Heavy use | Team / business | Overage |
|---|---|---|---|---|---|
| GitHub Copilot | Yes (limited) | Pro $10 ($15 of AI credits) | Pro+ $39; Max $100 | Business $19/seat; Enterprise $39/seat | $0.01 per AI credit |
| Claude Code (Claude plans) | No Claude Code | Pro $20 ($17 billed annually) | Max $100; Ultra $200 | Team $25/seat standard, $125 premium; Enterprise $20/seat + API-rate usage | Usage credits / API rates |
| OpenAI Codex (ChatGPT plans) | Free and Go ($8), desktop app | Plus $20 | Pro $100 / $200 / $500 | Business $25/user ($20 billed annually) | Extra credits |
| Cursor | Yes (limited) | Plus $8 (Grok only); Premium $30 | Super $100; Ultra $200 | Teams from $30/user | Third-party models at API list price |
| Kiro | 50 credits | Pro $20 (1,000 credits); Pro+ $40 | Pro Max $100; Power $200 | $20/seat, 500 pooled credits | $0.04 per credit |
| Devin | Yes (light) | Pro $20 | Max $200 | Teams $80 + $40 per dev seat | At API pricing |
| Factory | Yes, with your own keys | Pro $20 | Plus $100; Max $200 | Teams $60 + $40/seat | Custom on Business |
| Google Antigravity | Yes, individuals | Google AI Pro | Google AI Ultra | From $30/seat via Google Cloud, or pay-as-you-go | Consumption pricing |
| OpenHands / Cline / Aider | Open source | Free; you pay your model provider directly | Your API bill | ||
Three things decide whether a plan is worth it. First, what is inside the price: Cursor's paid plans cover Grok and Cursor models, while Claude or GPT models in Cursor are billed separately at API list price. Second, how usage is metered: credits (Copilot, Kiro), weekly allowances (Cursor, Claude) or five-hour windows (Codex on Plus) behave very differently when an agent loops on a failing test. Third, what governance the team tier adds — SSO, audit logs, central spend caps. Gartner warned in June 2026 that AI coding costs could overtake the average developer's salary by 2028; set per-seat spend limits on day one.
GitHub Copilot cloud agent, Claude Code cloud sessions, OpenAI Codex Cloud, Cursor cloud agents and Devin all run tasks on remote machines and hand back a branch or pull request. Google Jules also did, but it is read-only since November 11, 2026 and shuts down on December 31.
The differences are in isolation and control. Copilot offers a cloud sandbox that can work across several repositories, a GitHub Actions-based environment capped at 59 minutes per session, or a remote environment you connect; it works on one branch and opens one pull request per task. Claude Code cloud sessions run on a fresh clone in an Anthropic-hosted or self-hosted environment, and since November 4 can start with no repository at all. Cursor added cloud agents on machines you manage in September 2026. If your security team will not let source code leave your network, the self-hosted runner options (Claude Code, Cursor, Copilot remote environments) or a self-hosted OpenHands are the ones to evaluate.
The most model-agnostic are the open-source agents — OpenHands, Cline and Aider work with almost any provider, including local models — plus JetBrains Air, Factory and GitHub Copilot, which let you bring your own subscription or API key. Claude Code is Claude-only but runs through Amazon Bedrock, Google Cloud or Microsoft Foundry; Codex CLI adds Bedrock and Vertex AI providers.
Model choice matters for two reasons. One is contracts: routing the model through your own AWS, Google Cloud or Azure account keeps prompts and code under agreements you already have — the same logic we use for HIPAA-compliant AI agents. The other is lock-in: Cursor's plans now bundle Grok models and bill other vendors' models at API list price, so "multi-model" no longer means "same price for every model". Check what your plan covers before standardising on one model.
Terminal agents that record their own authorship in git are the main option: Claude Code adds configurable attribution to commits and pull requests, and Aider commits every change with "(aider)" in the author name or a Co-authored-by trailer. For line-level provenance, open-source tools such as Git AI store which agent, model and session wrote each line in git notes.
Commit trailers tell you that an agent was involved; they do not tell you which lines it wrote or which prompt produced them. Aider's git docs show the simplest model: every edit is its own commit, so git blame and git revert work at agent-step granularity. Git AI goes further, attributing lines to the agent, model and session across Claude Code, Codex, Cursor, Copilot and others, and keeping that data through rebases and squashes. For audited codebases, require one of these plus branch protection, so every merged line has a known author and a named human reviewer.
Agentic desktop IDEs — Cursor, Devin Desktop, Kiro, Google Antigravity, JetBrains Air and the Codex and Claude desktop apps — run the build and the test suite locally, iterate on failures, and hand off to cloud agents or CI for the pull request. "Ship" should still mean your CI/CD pipeline after human review, not the agent deploying on its own.
What separates them for a team is approval control. Kiro's new "Approve for me" mode lets a model approve routine actions and block risky ones; Cline asks before every step; Claude Code and Codex use allow/ask/deny permission rules that an admin can enforce centrally. Cursor's Live Apps let a cloud agent host an internal app behind a link — useful for internal tools, but keep production deploys behind your normal pipeline and branch protection.
As of November 2026, six platforms cover all three surfaces under one admin plane: GitHub Copilot, Claude Code, OpenAI Codex, Cursor, Devin and Kiro. Google Antigravity (app, CLI and IDEs via Google Cloud) and JetBrains Air (IDEs, web and CLI, with cloud runs rolling out) are close behind.
For an enterprise, the deciding factor is usually the existing stack. If your code lives on GitHub, Copilot keeps agents inside your PR, branch-protection and audit flow. On AWS, Kiro's new Enterprise Management preview sets one policy across IDE, CLI and web, and pools credits through Okta or Microsoft Entra ID. On Google Cloud, Antigravity Business bills per seat or pay-as-you-go with spend caps. Claude Code and Codex work across all three clouds and Git hosts. Pick the one your identity provider, audit and procurement can approve fastest.
A coding agent can control anything it can reach through a shell or a connector: git, package managers, compilers and test runners, Docker, linters and scanners, browsers, and — through MCP servers — issue trackers, databases, cloud consoles, CI systems and chat tools such as Slack. In practice its reach equals the permissions of the account and machine it runs on.
That is why the useful question is not "what can it control" but "what should it be allowed to control". Give the agent the test runner, the linter and a scratch database; keep production credentials, deploy commands and payment systems out of reach. Our MCP server development guide covers scoping tools to read-only and per-tenant access, and the AI agent security checklist lists the controls we expect before an agent touches shared systems.
Three shifts matter more than any single model release: tools now plug in through MCP and Agent Skills, work is moving from the editor to background cloud agents that return pull requests, and buyers increasingly evaluate agent governance — permissions, audit and spend — as hard requirements. Pick the platform that fits all three, not the one with the best demo.
Benchmarks measure curated tasks. In a real codebase, these decide the outcome:
A startup MVP team (2–6 engineers). Use one terminal or IDE agent everyone knows well, plus a cloud agent for well-specified chores (dependency bumps, test coverage, small bugs). Standardise the instruction file and review checklist on day one. Avoid three overlapping agents; conventions fragment fast.
An enterprise with security and compliance review. Start from your Git host and identity provider: an agent that lives inside your existing PR, branch-protection and audit flow (Copilot cloud agent if you are on GitHub, or an enterprise plan with SSO and admin policies) is easier to approve than a best-in-class tool that bypasses those controls.
Regulated data (HIPAA, PCI, financial records). The question is not which agent is smartest, it is whether regulated data can ever reach it. Keep production data out of dev environments entirely, use synthetic fixtures, and prefer setups where you control execution and the model endpoint — a self-hosted open-source agent, or a commercial agent routed through your own cloud account under your existing agreements. Get written compliance sign-off on the data flow before the pilot.
The review burden moves, it does not disappear. In the 2025 Stack Overflow Developer Survey, 84% of developers used or planned to use AI tools, but only about 31% used AI agents at all, more developers distrusted AI accuracy (46%) than trusted it (33%), and 66% named "almost right, but not quite" answers as their top frustration. Ten agent PRs a day means ten reviews a day.
Felt speed is not measured speed. METR's randomized trial of experienced open-source developers (early-2025 tools) found they took 19% longer with AI, while believing they were about 20% faster. Tools have improved since; the lesson holds — measure cycle time and defects, not feelings.
Security debt. Veracode's Spring 2026 update, testing 150+ models, found only about 55% of generated code passed its security tests — essentially flat for two years while syntax correctness climbed. Agent output needs the same SAST, dependency scanning and threat review as human code.
Cost blowups. Gartner warned in June 2026 that by 2028 AI coding costs could overtake the average developer's salary as token use and consumption-based licensing grow; coverage of the forecast cited monthly bills from $20–$100 up to $2,000–$5,000 per developer. Set per-seat spend limits and watch for agents looping on failing tests. The same logic applies to agents in your product: see what an AI agent costs to build and run.

Let agents run with light oversight when the task is well-specified, the blast radius small and the tests good: chores, coverage, refactors, internal tools. Put senior engineers in charge when the work involves architecture decisions, security boundaries, regulated data, payments, data migrations, or a codebase with weak tests — where "almost right" becomes an incident. It is also why AI agent projects fail: autonomy before verification. The pattern that holds up: senior engineers write the spec and the tests, agents produce the first draft, and humans own review, merge and deploy — with evaluation and observability on anything the agent touches in production. It is the same principle behind Kite, our open-source agent framework: treat the LLM as an untrusted component and design the controls around it.
With the same rules that make production AI safe — the ones BeevR publishes for the agents it builds: the model is an untrusted component, the context is engineered, the output is tested before it is trusted, and a named senior engineer owns every merge. None of these rules depends on which vendor's agent is in the loop, which matters because the platform table above will look different in six months. Ask any studio or AI agent developers you hire how they cover each point.
The proof we can point to is public: two open-source projects you can read line by line, and case studies of AI systems we took from prototype to production. Read the code or the case studies rather than taking a vendor's word — including ours.
For regulated builds, the same controls are packaged as HIPAA-compliant AI agent development.
There is no single best one. Gartner's 2026 Magic Quadrant names Anthropic, Cursor, GitHub and OpenAI as Leaders, but the right choice depends on where your code may run, your Git host and identity setup, and whether you need self-hosting. Pilot two on your own repo and measure.
They can be, if regulated data never reaches the agent: synthetic test data, no production credentials in dev, controlled execution, a model endpoint under your agreements, and human review of every merge. Get compliance sign-off on the data flow first.
Not for production software as of November 2026. Agents are strong at well-specified tasks with good tests; they are weak at ambiguous requirements, architecture and judging security trade-offs. They change team shape — fewer people typing, more specifying and reviewing.
Entry plans run $10–$30 per developer per month (Copilot Pro $10, Claude Pro and ChatGPT Plus $20, Cursor Premium $30); heavy-use tiers run $100–$200, and usage billing can go higher. Reported monthly bills range from tens of dollars to several thousand per developer. Set spend limits from day one.
Open source (OpenHands, Cline, Aider) gives you control of execution and model choice, which matters for regulated data, at the cost of setup and maintenance. Commercial platforms give you polish, governance and support.
No new work since November 11, 2026: Jules is read-only and shuts down on December 31, 2026. Export your settings and sessions with Jules Tools; your code and pull requests stay in GitHub. Google points users to Antigravity.
We are a senior, founder-led AI and software studio in Hanoi, Vietnam — fixed price per phase from $10K, full IP and repository ownership from day one, and a named senior engineer accountable for every merge. If you want agent-level speed without agent-level risk, see how we build production-ready AI agents and software, or tell us what you are building and we will tell you honestly which parts agents should do and which need people.