AI Coding Agent Pricing Compared: Cost per Accepted Task

AI coding agent pricing is best compared by cost per stable accepted task, not by seat price, token rate, or prompt allowance. A task counts only when the requested change passes its checks, survives review, and does not return as avoidable rework during the chosen observation window. This article shows how to calculate that unit across GitHub Copilot, Cursor, Codex, Claude Code, Factory, and Devin.

In this guide you will learn

• Why price per seat, token, or prompt is a poor proxy for engineering value.
• How to calculate cost per accepted task across subscriptions, metered usage, review, rework, and failed attempts.
• How the commercial models of GitHub Copilot, Cursor, Codex, Claude Code, Factory, and Devin differ as of 18 September 2026.
• How to run a two-week evaluation that produces a defensible purchasing decision.

Key insights

• Reviewer time usually matters more than the model bill. A cheap run that creates a large, ambiguous diff can cost more than an expensive run that produces a small, testable change.
• “Included usage” is an allocation rule, not a free resource. Seat fees still need to be assigned to accepted work, and limits can shift work into overage or slower fallback models.
• Acceptance must be defined before the trial. Passing CI is necessary, but a task should also satisfy scope, security, maintainability, and product requirements.
• The cheapest tool varies by workload. Interactive copilots, terminal agents, autonomous task agents, and background agents should not be forced into one benchmark.
• Measure distributions, not a single average. Median cost shows the normal case; the 90th percentile exposes expensive failures and review traps.

How should AI coding agent pricing be compared?

A seat is not a completed change

Most pricing pages expose one of three units: a monthly seat, a bundle of credits, or metered model usage. None captures the work required after generation. The agent may misunderstand the repository, choose the wrong abstraction, create tests that prove its own mistake, or consume senior review time explaining a diff that should have been discarded. Product category also matters: the trade-offs in choosing an AI coding harness are different from those in buying an autonomous background agent.

An accepted task needs a stable definition before the trial begins. For a product team, it can mean all of the following:

• The requested behavior is present and the acceptance criteria are demonstrably met.
• Automated checks pass, including the tests that cover the changed behavior rather than only implementation details.
• The diff stays within the agreed scope and follows the repository’s architecture and dependency rules.
• Security, privacy, and data-handling requirements are satisfied.
• A reviewer can explain the change, its failure modes, and the evidence used to approve it.
• No agent-attributable rollback or corrective patch appears during a defined seven- or fourteen-day observation window.

Cost per accepted task = (allocated seat cost + metered usage + review cost + rework cost + CI and runtime cost + failed-attempt cost) ÷ accepted tasks.

That equation prevents a common mistake: counting an agent response as output even when a human must rebuild it.

Which stages belong in the task-cost funnel?

Record every task from assignment to acceptance. Useful statuses are attempted, submitted, CI-passing, review-approved, merged, and stable after seven or fourteen days. The gaps show where money is lost. A low submit-to-accept rate signals poor task selection, insufficient repository context, or weak verification. A high merge-to-stable failure rate signals that the review gate is accepting plausible code without enough evidence.

How do AI coding agent pricing models differ in September 2026?

Prices change frequently. The table below records public list prices checked on 18 September 2026 and should be refreshed before purchase. Taxes, enterprise discounts, regional prices, premium models, and overages can change the result.

GitHub now expresses variable agent consumption as AI credits, where one credit equals one US cent, while still separating unlimited paid-plan completions from agentic features. OpenAI exposes both plan-based access and model-level token rates. Claude Code combines subscription limits with optional API usage. These structures are commercially different even when the headline monthly number is similar. Blazity’s analysis of buying compute versus subscribing for AI inference explains the same fixed-cost-versus-variable-cost decision at the infrastructure layer.

Why is token price an incomplete comparison?

Tokens are valuable for cost diagnosis, particularly for long repository contexts, cache performance, and verbose outputs. They are a poor cross-product value metric. One agent may use more tokens but finish with a reviewable patch. Another may appear efficient because it stops early, misses edge cases, or leaves integration work to the developer.

Public vendor evaluations reinforce this point. Cognition reported a measured FrontierCode task cost of $2.68 for Fable 5.1, $3.51 for Claude Opus 5, and $1.43 for Devin Fusion in one benchmark configuration. Those figures are useful evidence that model choice and orchestration change task cost, but they are not a universal price list and should not be projected directly onto a private codebase. Model selection should follow task difficulty and verification cost; the guide to choosing the best LLM for an AI agent provides a complementary decision framework.

What does a cost-per-accepted-task calculation look like?

Consider a two-week trial with 60 comparable maintenance tasks. The team pays $40 per seat for the evaluated tool, assigns ten seats, and attributes half of the monthly seat cost to the two-week trial. Metered usage and runtime total $210. Reviewers cost the company $95 per hour when salary, benefits, and overhead are included.

The agent submits 52 tasks. Forty pass CI, 34 are approved, and 31 remain stable after the observation window. Review takes 1,020 minutes. Material rework takes 22 engineering hours. CI and preview infrastructure cost $85.

This is an illustrative model, not a market benchmark. Its lesson is the cost composition: the tool and infrastructure account for $495, while review and rework account for $3,705. A 20% discount on the subscription saves $40. Cutting rework by five hours saves $475.

Compare against a human baseline

The decision requires a control. Select matched tasks from the same repositories and risk classes. Record the same outcome: total labor and infrastructure divided by stable accepted tasks. Do not compare agent-assisted bug fixes with unaided architectural work, or greenfield scaffolding with incident remediation.

For small samples, report the median, interquartile range, and 90th percentile. Also split results by task class: bounded refactor, test creation, dependency upgrade, bug fix, documentation, UI change, and cross-service work. A tool can be excellent for one class and uneconomic for another.

How do you run a fair two-week AI coding agent evaluation?

1. Create a representative task set

Choose 40 to 100 tasks with clear acceptance criteria. Exclude work blocked by external decisions. Label complexity, repository familiarity, expected files touched, security sensitivity, and whether the task requires product judgment. Preserve a few deliberately difficult tasks to expose failure behavior.

2. Freeze the environment and policy

Use the same repository revision, test suite, network permissions, secrets policy, and review standards. Give every tool equivalent context. If one product receives a detailed architecture file and another receives only the prompt, the benchmark measures setup quality rather than agent capability.

3. Capture machine and human events

For each attempt, store tool, model, plan, input/cached/output usage when available, wall-clock runtime, human steering minutes, CI runs, reviewer minutes, requested changes, rework minutes, merge status, and post-merge incidents. Connect retries to the original task so discarded attempts do not disappear. The same traces, costs, and approval evidence also support AI agent observability; a monthly invoice alone cannot explain why a task became expensive.

4. Blind review where practical

Remove tool identity from the patch when reviewers can assess it without losing essential context. Apply the same checklist: correctness, scope, tests, security, observability, maintainability, and rollback plan. Track substantive review comments separately from formatting preferences.

5. Set purchasing thresholds in advance

Examples include: at least 65% stable acceptance for bounded tasks; median review time below the human baseline; no increase in change failure rate; 90th-percentile task cost below a defined ceiling; and a minimum developer satisfaction score. A trial without thresholds tends to become a debate about impressive demos. If the organization is still deciding which controls belong around autonomous work, use the AI governance maturity model to define the minimum gate for the pilot’s risk level.

What should procurement ask before selecting an AI coding agent?

Cost is only one part of suitability. Security controls, repository access, auditability, data retention, model choice, deployment topology, and administrative controls can exclude a product before economics matter. For high-risk repositories, an architecture and code review can turn those concerns into explicit technical and organizational requirements before vendor evaluation begins.

When does the cheapest AI coding agent become expensive?

Three patterns inflate accepted-task cost. First, large speculative diffs consume review time and hide defects. Second, repeated context reconstruction burns tokens and developer attention. Third, agents are assigned tasks with unresolved product decisions, so generation begins before the work is actually ready.

Reduce cost by shrinking batches, maintaining concise repository instructions, exposing deterministic verification commands, caching stable context, and routing tasks by risk. Use fast inexpensive models for discovery and mechanical edits, then escalate ambiguous or high-risk work. Once a trial shows where the agent works, the research-backed guidance on scaling AI agent use helps extend adoption without erasing those task boundaries. The goal is the smallest total effort required to reach trusted acceptance.

FAQ on AI coding agent pricing

Which AI coding agent is cheapest?

There is no universal cheapest option. GitHub Copilot and entry-level plans from Cursor, Claude, Factory, and Devin are inexpensive to start, while metered products can be cheaper for intermittent use. The answer changes when review time, acceptance rate, overages, and failed attempts are included.

Should we compare agents by token cost?

Use token cost to understand a tool’s internal spend, not to rank business value. Compare cost per stable accepted task and inspect tokens as one explanatory variable.

How long should an agent pricing trial run?

Two weeks is enough for a directional result if the task set is representative and contains at least several dozen attempts. High-risk adoption decisions should continue through a longer observation window to capture post-merge defects and operational impact.

What is the most important hidden cost?

Reviewer and rework time. It is often several times larger than the subscription or token charge, especially when agents produce broad diffs or weak evidence.

Sources

• GitHub Copilot plans
• GitHub Copilot plan documentation
• Cursor pricing
• OpenAI: Flexible pricing for Codex
• OpenAI GPT-5.6 Sol model pricing
• OpenAI ChatGPT rate card
• Anthropic: Using Claude Code with Max
• Claude Team plan updates
• Factory pricing
• Factory cost and productivity guidance
• Devin pricing
• Cognition: Fable 5.1 benchmark costs