Agentic Coding in 2026: Models, Tools, and Cost

Executive summary

This page merges two earlier working documents into one verified reference: a practical paper on the model-and-tool landscape (with prices and quotas) and a conceptual paper on the shift from code assistants to role-based agent systems. It is written for developers and technical leads who build with AI coding agents and need to make model, tool, and budget decisions.

Three questions frame everything:

1. Which models matter for agentic coding right now?
2. How do the major tools differ, especially where they ship proprietary or tool-specific models?
3. What does this actually cost as a developer moves from occasional assistance to deep debugging and then to full agentic delivery?

The short answers:

• There is no single universal winner. The outcome depends on the interaction of three layers: the base model, the tool or harness, and the pricing abstraction.
• Agentic coding is role-based, not model-centric. Effective systems combine a planner, an executor, and cheaper supporting models.
• Many tools are no longer thin wrappers. Cursor ships in-house and jointly trained models plus a router; Devin ships the SWE-2 family plus Adaptive and Fusion; OpenAI ships Codex-specific models; GitHub meters everything through AI credits.
• Cost is driven by repeated large-context prompts, retries, tool loops, and cache behavior — not by the plan’s sticker price alone.
• Benchmark claims are benchmark-specific. Every vendor’s launch table now spans five or more benchmarks, and wins flip from row to row.

All facts below were checked against official vendor documentation on October 12, 2026. Model lineups and prices move fast; every claim links to its live source. A list of corrections made to the original drafts is at the end.

1. From assistants to agents

Traditional AI coding assistants focus on autocomplete and isolated code generation. Agentic systems extend this with:

• task planning and decomposition,
• iterative execution with feedback loops,
• tool usage (repositories, shells, CI/CD systems, APIs), and
• persistent context and memory.

In practice, the agentic loop looks like this:

1. Understand the objective and assemble context.
2. Plan or decompose the work.
3. Execute actions: read, write, edit, run commands, run tests.
4. Evaluate results from tool output and test runs.
5. Iterate until the task is complete or a human intervenes.

A compact version of the same loop, synthesized from vendor documentation:

retrieve context -> plan -> edit / run -> inspect results -> repeat

The effectiveness of this loop depends heavily on choosing the right model for each stage. That is the core argument for multi-model systems: reasoning, code generation, and high-throughput transformations have different cost and latency profiles.

2. The agentic coding stack

A useful mental model is a three-layer stack.

Synthesis: in practice, productivity depends on the whole stack, not on the base model alone.

3. Model landscape

3.1 Four practical tiers

Frontier reasoning models — the highest reasoning capability available.

• Examples: OpenAI GPT-6.x and GPT-5.5/5.6, Anthropic Fable 5.1 and Mythos 5.1, Google Gemini 4 Argon.
• Best for: system design, large-scale refactoring plans, complex debugging, and acting as the planner in an agent.
• Trade-offs: higher latency and cost; overkill for repetitive tasks.

High-performance coding models — strong coding with better efficiency.

• Examples: OpenAI GPT-5.4, Anthropic Opus 5.5 and Sonnet 5.5, Google Gemini 3.x Pro.
• Best for: implementing well-defined tasks, translating plans into code, iterative development.
• Trade-offs: less reliable for long-horizon reasoning without a planner.

Lightweight and high-throughput models — speed and cost efficiency.

• Examples: OpenAI GPT-5.4 mini and nano, Anthropic Haiku 5.5, Google Gemini 3.x Flash, and similar open models.
• Best for: bulk transformations, log analysis, summarization, formatting, and cheaper subagents.
• Trade-offs: limited reasoning depth; not for complex decisions.

Open and self-hosted models — flexibility and control.

• Examples: DeepSeek V4 (Pro/Flash), GLM-5.2/5.3, Kimi K2.7 Code and K3, Qwen 3.x, MiMo V2.x, MiniMax M2.7/M3, Muse Spark.
• Best for: sensitive codebases, on-premise deployments, high-volume internal tooling.
• Trade-offs: variable hosting quality; you own reliability engineering. This tier improved fast — OpenCode’s curated “Go” plans exist precisely because open models now reach near-proprietary coding quality for many tasks.

3.2 Cross-cutting capabilities

Capabilities that matter more to agent systems than raw benchmark scores:

• Tool and function calling — structured interaction with external systems, schema-constrained outputs, and reliable step-by-step execution.
• Long context windows — repository-level reasoning and full-PR analysis. Current flagship models offer 400K to 1M+ tokens, but long prompts are usually priced higher.
• Multimodality — combining code, screenshots, logs, and UI inputs, useful for debugging and full-stack work.

3.3 Verified snapshot of current models

List prices per 1M tokens, standard (non-batch) tier, verified October 12, 2026. Input/output prices exclude prompt-cache discounts, which typically cut cached input to roughly 10% of the list price.

Version notes that matter for budgeting:

• Long-context surcharges are common. GPT-5.4 doubles input price above 272K prompt tokens; Haiku 5.5 bills 5x above 100K prompt tokens; OpenAI long-context tiers apply above 272K. Long-context pricing is where “cheap” models stop being cheap.
• Batch and cache discounts are large. Anthropic batch pricing is 50% off; cache reads are 5–10% of input (2.5% on Fable 5.1). OpenAI cached input is 90% off for the GPT-5.4 family and batch is 50% off.
• Retired models linger. Claude Sonnet 4 and Opus 4.1 (the stars of the April drafts) are retired on the Claude API and remain only on select cloud platforms.

3.4 What is verifiable versus judgment

Directly verifiable from official sources:

• context length, max output, and knowledge cutoff,
• tool use / function calling / code execution support,
• vendor positioning, and
• price.

Hard to verify in a stable, universal way: “model X is the best debugger” or “model Y is always better at frontend.” Those are workflow-level judgments or benchmark-specific observations, not facts.

4. Why model rankings differ: the benchmark lens

Claims of model superiority are often biased by the benchmark being cited. Official benchmark descriptions support that skepticism.

The multi-benchmark reality is now visible even in vendor marketing. Google’s Gemini 4 Argon launch page reports at least sixteen benchmarks across knowledge work, agentic coding, science, long context, computer use, multimodal understanding, and cybersecurity — and the top row changes depending on the benchmark (GPT-6 Astra leads on FrontierSWE and OSWorld; Claude Opus 5.5 leads on Terminal-bench 4.0; Argon leads on DeepSWE, Vibe Code Bench, and most knowledge-work rows).

Synthesis: because official benchmark scopes differ so much, any “best coding model” statement should be tied to a benchmark family and a workflow, not treated as universal.

5. Tool landscape

5.1 Categories

5.2 Tool-by-tool

GitHub Copilot

Verified facts:

• Plans: Free and Student at $0; Pro $10/month, Pro+ $39/month, Max $100/month; Business $19/seat and Enterprise $39/seat. Plans
• Billing is now usage-based in GitHub AI credits (1 credit = $0.01). Individual allowances: Pro 1,500 credits ($15 value: 1,000 base + 500 flex), Pro+ 7,000, Max 20,000. Business and Enterprise include 1,900 and 3,900 credits per user per month, pooled. Plans, models and pricing, individual billing
• Code completions and next-edit suggestions are unlimited on paid plans and are not billed in credits.
• The model roster spans OpenAI (GPT-5.x/6.x, Codex variants), Anthropic (Haiku 4.5 through Fable 5.1), Google (Gemini 3.7/3.8 Flash), xAI (Grok 4.5–4.7), Moonshot (Kimi K3), and Microsoft (MAI-Code-1.1-Flash). Premium models such as Opus 5.5 and Fable 5.1 require Pro+ or Max. models and pricing

Interpretation: Copilot is the most mainstream assistive layer and now the most aggressively metered one. The April draft’s “300/1,500 premium requests at $0.04/request” world is gone — request-based billing is legacy, and token-priced AI credits are the current system. Cost predictability is now a function of your token habits.

Cursor

Verified facts:

• Plans: Hobby free; Pro $20/month, Pro+ $60/month, Ultra $200/month; Teams Standard $40/user; Enterprise custom. A reduced “Start” plan (₹649/month) exists for developers in India. Pricing, models & pricing docs
• Pro and above include two usage pools: the Cursor Models pool (Composer 2.5 and the jointly trained Grok 4.5–4.7 models) and the Other Models pool, charged at each third-party model’s API rate. models & pricing docs
• Composer 2.5 is Cursor’s in-house model at $0.50 / $2.50 (fast variant $3 / $15). Grok 4.5–4.7 are jointly trained by Cursor and SpaceXAI, at $2 / $6 base. models & pricing docs
• Cursor Router powers Auto requests with Cost, Balance, and Intelligence modes; third-party requests on Teams/Enterprise include a $0.25 per million-token Cursor Token Rate. Cursor Router
• Tab remains Cursor’s specialized autocomplete model, with multi-line edits, cross-file jumps, and next-location prediction. Tab docs
• Cloud Agents run in isolated environments and can be launched from the editor, CLI, mobile, or automations. Cloud agents
• Cursor’s own guidance: daily agent users typically run $60–$100/month total usage; power users often $200+/month. models & pricing docs

Interpretation: Cursor is a multi-model orchestration product with a substantial proprietary layer — in-house models, a router, and a specialized completion model. The pricing model rewards people who stay in the Cursor Models pool and punishes heavy use of frontier third-party models.

Claude Code

Verified facts:

• Anthropic describes Claude Code as its agentic coding tool that lives in the terminal, available across CLI, IDE, and desktop. Overview
• Claude Code is included in all paid Claude plans and draws from the same usage pool as Claude chat, with five-hour and weekly windows. Claude pricing
• Anthropic publishes usage averages for enterprise deployments: roughly $13 per developer per active day and $150–250 per developer per month, with costs below $30 per active day for 90% of users. Manage costs
• Cost tooling is first-class: /usage (per-model token and plan usage, cache statistics, attribution by skills, subagents, MCP servers, and loops), /compact and /clear, effort controls, subagent model selection, MCP tool deferral, and preprocessing hooks. Manage costs
• Subscription prices: Pro $20/month ($17 annual), Max from $100/month (5x and 20x tiers); usage credits continue work past plan limits at standard API rates. Claude pricing

Interpretation: Claude Code is a product wrapper around Claude models plus terminal workflows, permissions, and unusually transparent cost reporting. It is the clearest example of a tool whose cost model is “your context habits, metered.”

OpenAI Codex

Verified facts:

• Codex spans the ChatGPT desktop/mobile app, web, CLI, and IDE extensions, with Codex Cloud for parallel cloud tasks. Codex docs
• The Codex app is a “command center for agents”: parallel agent threads, git worktree support, skills, and scheduled automations. Introducing the Codex app
• Permission modes are now Ask for approval, Approve for me (automatic review), Full access, and Custom (config.toml) — each combining a sandbox scope with an approval policy. Permissions
• Codex is included with paid ChatGPT plans (Plus, Pro, Business, Enterprise, Edu), with optional additional credits. Introducing the Codex app
• Model layer: GPT-5.1-Codex ($1.25 / $10) through GPT-5.3-Codex ($1.75 / $14) and the GPT-6.x family. OpenAI pricing

Interpretation: Codex is both a tool-native model family and a product workflow layer. It is the clearest example of why “the model” and “the tool” should not be collapsed into one concept.

Devin (Devin Desktop, formerly Windsurf)

Verified facts:

• The Windsurf editor and docs now live under Cognition as Devin Desktop, an AI IDE with local Devin, cloud delegation, and an Agent Command Center. Legacy Windsurf auth still works on some surfaces. Introducing Devin Desktop
• The in-house model family is now SWE-2 (successor to the SWE-1.x line), alongside Claude, GPT, Gemini, and Grok models. Devin Desktop models
• Adaptive is Cognition’s intelligent model router, documented at $0.50/M input, $2.00/M output, and $0.10/M cache read, and marked as the recommended default in the model list. Adaptive, Devin Desktop models
• Fusion pairs a frontier lead model with a cost-efficient sidekick to get frontier behavior at lower cost. Fusion
• Plans: Free; Pro $20/month; Max $200/month (weekly quota, no daily cap); Teams from $80/month with $40/month full seats. Pro and full seats include daily and weekly quotas spanning sessions, CLI, and Desktop; on-demand credits cover overages and roll over. Self-serve plans

Interpretation: the April draft’s Windsurf story — a $20/$200 editor with SWE-1.5 and Adaptive — survived the rebrand almost intact, but the brand, model family (SWE-2), and plan structure all changed. Deployments must plan a migration, not just a billing update.

Pi

Verified facts:

• Pi is a minimal, extensible terminal coding harness. Pi docs
• It works with subscription sign-in or API keys across a very wide provider list (Anthropic, OpenAI, Google, GitHub Copilot, OpenRouter, OpenCode Zen and Go, local models, and custom endpoints). Quickstart, providers
• The visible tool surface stays small — file read and search, edits, and shell commands — and sessions are stored as branchable JSONL trees with /compact, /fork, and /clone equivalents. How Pi works

Interpretation: Pi is a user-controlled harness rather than a turnkey product. That is its strength and its weakness: maximum flexibility, but you assemble the workflow advantages other products bake in by default.

OpenCode

Verified facts:

• OpenCode is an open-source AI coding agent available as a terminal UI, desktop app, or IDE extension; OpenCode v2 is now available alongside the v1 line. Intro
• Built-in primary agents are Build and Plan; built-in subagents are General, Explore, and Scout. Permissions are configurable per agent and per tool. Agents
• Provider access is bring-your-own-key, with OpenCode Zen as a curated provider and OpenCode Go as an optional low-cost subscription: $10/month or $40/month (Go Plus) for access to popular open coding models, with per-model monthly usage allowances (commonly $15–$80 of included usage per model, expressed as 5-hour/weekly/monthly limits). Go
• Go’s model list includes GLM-5.2/5.3, Kimi K2.7/K3, DeepSeek V4 (Pro/Flash), Qwen 3.x, MiniMax, MiMo, Grok 4.6/4.7, GPT-5.6 Luna, and Claude Haiku 5.5. Go

Interpretation: OpenCode sits between a minimal harness and a polished product: more built-in agent structure than Pi, fully open, and now with a curated provider that makes open-model routing economically attractive.

6. Proprietary model layers inside the tools

Synthesis: comparing coding systems only at the base-model level misses a large part of the real-world performance and cost story.

7. How these systems work under the hood

Vendor docs describe different implementations, but they consistently reveal the same building blocks:

1. Context assembly — file retrieval, open tabs, repo cloning, project instructions, tool definitions.
2. Planning or task framing — explicit or implicit decomposition.
3. Tool execution — reading, writing, editing, running shell commands, invoking tests.
4. Observation and iteration — using tool results and test output to continue.
5. Permissions and sandboxing — determining how autonomous the system may be.

Documented mappings:

• Claude Code reads files as needed, proposes or makes edits, runs tests, and summarizes context through compaction. Claude Code docs
• Codex exposes explicit sandbox scopes and approval policies, and the app runs parallel agents over isolated worktrees. Codex permissions, Codex app
• Cursor Cloud Agents run remotely and can auto-run terminal commands; Cursor Router picks the model per request. Cloud agents, Cursor Router
• Pi makes the loop visible: small tool surface, JSONL session trees, explicit branches. How Pi works
• OpenCode’s TUI supports file references, shell execution, and switchable primary agents with distinct permissions. OpenCode docs

Common reference architectures:

• Planner–executor: a frontier model plans; a strong coding model executes; lightweight models support. This is the pattern that multi-model pricing now optimizes for.
• Single-model: one model does everything. Simpler, usually less efficient.
• Tool-centric agent: the model decides; tools execute. Determinism lives in the tools.
• Human-in-the-loop: AI proposes, humans approve. Still the default for production repositories.

8. Choosing models and tools by use case

8.1 Model selection by task

8.2 Tool fit by engineering area

This table is editorial fit guidance, not a benchmark result.

8.3 Cost–capability trade-offs by tier

9. Cost model

9.1 Why pricing is difficult to compare

Each tool uses a different abstraction:

• GitHub Copilot: subscription plus usage-based GitHub AI credits (1 credit = $0.01).
• Cursor: subscription with included usage pools plus on-demand usage at model API rates.
• Devin: subscription with daily/weekly quotas plus shared on-demand credits.
• Claude Code: subscription usage pools (shared with Claude chat) or API-token billing through the Console.
• Codex: included in ChatGPT plans, with additional credits available.
• OpenCode Go / Pi: subscription (Go) or direct provider billing (Pi and OpenCode bring-your-own-key).

That is why two developers can both say they “use Claude” and face very different monthly costs.

9.2 Scenario assumptions

To make pricing comparable, this page uses the same normalization assumptions as the original paper. These are not vendor numbers:

• Occasional assistance: ~0.5M input and 0.1M output tokens per month.
• Large-codebase debugging: ~5M input and 0.6M output tokens per month.
• Full agentic app build: ~20M input and 2M output tokens per month.

These scenarios exclude prompt caching, which varies too much by tool and workflow. In practice, caching reduces real spend — sometimes dramatically — which is why cached-input pricing matters.

9.3 API-only baseline costs

If a team used these models directly via API at the above monthly token volumes, without caching:

Sources: OpenAI pricing, Anthropic pricing, Cursor models & pricing. Google’s own API pricing should be checked at ai.google.dev.

Synthesis: DIY harnesses such as Pi or OpenCode can be far cheaper than premium SaaS plans if a team manages provider selection, context handling, and routing discipline itself.

9.4 Verified plan prices

9.5 Illustrative all-in monthly ranges

These ranges combine verified plan prices with documented quotas and vendor-published usage statistics. They are budgeting illustrations, not vendor quotes. Your mileage depends on context size, retries, caching, and how many agents you run concurrently.

Basis for the ranges:

• Copilot: credit allowances (1,500 / 7,000 / 20,000 credits) against token-priced model rates. Heavy frontier-model use consumes credits quickly. Plans
• Cursor: Cursor’s published bands — daily agent users typically $60–100/month, power users $200+/month. Models & pricing
• Claude: Anthropic’s enterprise averages — $13 per developer per active day, $150–250 per month, below $30 per day for 90% of users. Plans cap usage; credits cover the rest. Manage costs
• Devin: daily/weekly quotas on Pro; Max removes the daily cap; Teams shares on-demand credits. Self-serve plans
• OpenCode Go: per-model monthly allowances of $15–$80 in included usage, with 5-hour/weekly/monthly limits (5-hour = 20% of monthly, weekly = 50%). Go
• Pi: inherits the economics of whatever provider it routes to; compare against section 9.3.

9.6 Cost-control tactics supported by official docs

• Route automatically when quality allows. Cursor Router (Cost/Balance/Intelligence) and Devin Adaptive explicitly optimize for cost/quality trade-offs.
• Use cheaper subagents. OpenAI positions GPT-5.4 mini for coding subagents; Claude Code lets you set a model per subagent (for example, Haiku for simple tasks).
• Exploit caching and batching. Anthropic cache reads run 5–10% of input (2.5% on Fable 5.1) and batches are 50% off; OpenAI cached input is 90% off on the 5.4 family.
• Compact context aggressively. Claude Code documents /compact, /clear, custom compaction instructions, and moving instructions from CLAUDE.md into on-demand skills. Pi and OpenCode offer equivalent compaction.
• Watch quota and included usage. Copilot, Cursor, and Devin all ship usage dashboards; Claude Code’s /usage now breaks usage down by skills, subagents, MCP servers, and scheduled loops.
• Match reasoning effort to the task. Lower effort levels and disabling extended thinking where supported cuts output-token spend, which is the most expensive token class.
• Use open-model bundles when quality is sufficient. OpenCode Go exists specifically to make tested open coding models reliable and cheap.

10. Recommendations

10.1 For an occasional developer

• GitHub Copilot Pro ($10) if the priority is mainstream IDE integration and unlimited completions.
• Claude Pro ($20) if you want Claude Code included and mostly work in short sessions.
• OpenCode Go ($10) or Pi + a cheap provider if the priority is raw economics and you are comfortable with more setup.

10.2 For a developer in large codebases

• Cursor Pro+ ($60) for editor-native agent workflows with two usage pools.
• Claude Code for terminal-centric workflows and the most transparent cost instrumentation.
• Codex if the team lives in ChatGPT and wants app, CLI, IDE, and cloud under one plan.

10.3 For full agentic build workflows

• Cursor Ultra, Devin Max, Claude Max, and Codex all become viable; the choice depends on how much autonomy, cloud execution, and routing control you want.
• If cost sensitivity is high, OpenCode or Pi plus disciplined provider routing can materially undercut premium seats.
• Budget for concurrency, not just tokens: agent teams and parallel cloud sessions multiply usage in ways seat pricing does not show.

10.4 The most important strategic recommendation

Do not ask only “Which model is best for coding?” Ask instead:

1. Which part of the workflow matters most — inline assistance, repo-scale debugging, terminal work, or autonomous build loops?
2. Do we want a product with baked-in routing and proprietary optimization, or a harness we control ourselves?
3. Do we want predictable seat pricing, or are we comfortable with token-priced usage that varies with context and retries?
4. Where does the data go, and what is the retention policy? (OpenCode Go publishes per-model retention; Anthropic, OpenAI, and GitHub all document data handling.)

That framing is the most consistent with the official evidence reviewed here.

11. Key takeaways

• Agentic coding is a stack problem, not just a model problem.
• Model selection should be role-based: planner, executor, and lightweight support roles.
• Tool-native model layers are real and materially affect both quality and cost.
• Benchmark results are useful but benchmark-specific; vendor launch tables prove the point.
• The biggest pricing driver is usually not the plan fee; it is repeated context, retries, tool loops, and cache behavior.
• Pi and OpenCode matter because they expose the economics and workflow trade-offs more directly than all-in-one products.
• The landscape moved fast in 2026: plan names, model generations, and even product brands (Windsurf to Devin) changed within months. Verify before you commit budget.

12. Corrections made to the original drafts

During verification, the following claims from the April 2026 drafts were found outdated and were corrected:

• Anthropic models: Claude Sonnet 4 and Claude Opus 4.1 are retired on the Claude API. The current lineup is Fable 5.1, Mythos 5.1, Opus 5.5, Sonnet 5.5, and Haiku 5.5, all with 1M-token context at standard pricing. Sonnet 5.5 costs less than Sonnet 4 ($2/$10 vs $3/$15).
• GitHub Copilot billing: the “moving to AI credits on June 1, 2026” change shipped. Premium-request billing is legacy; AI credits (1 credit = $0.01) are current, Pro includes 1,500 credits, and a new Copilot Max tier exists.
• WindSurf: the product and docs now live under Cognition as Devin Desktop; the in-house model family is SWE-2, and plans are Free / Pro $20 / Max $200 / Teams from $80.
• Cursor: pricing and usage were restructured into two usage pools; the Auto mode became Cursor Router with Cost/Balance/Intelligence modes; Composer 2.5 and jointly trained Grok models are now the first-party line.
• OpenCode: Go now has two tiers ($10 and $40 Go Plus), new v2 docs, and additional built-in subagents (General, Explore, Scout).
• Claude Code cost averages: Anthropic now publishes ~$13 per active day, $150–250 per month, and below $30 per day for 90% of users (the April figures were lower and have been replaced).
• Codex permission modes: Suggest / Auto Edit / Full Auto became Ask for approval / Approve for me / Full access / Custom.
• OpenAI + Google frontier: GPT-5.4 is no longer the frontier (GPT-5.5/5.6/6.x exist), and Gemini 4 Argon replaced Gemini 2.5 Pro as Google’s flagship.
• Reference URLs: Anthropic docs moved to platform.claude.com and code.claude.com; GitHub billing docs were restructured; Cursor docs consolidated to cursor.com/docs. All links in this page point to the current canonical locations.

References

1. OpenAI, GPT-5.4 model page — https://developers.openai.com/api/docs/models/gpt-5.4
2. OpenAI, GPT-5.4 mini model page — https://developers.openai.com/api/docs/models/gpt-5.4-mini
3. OpenAI, GPT-5.1-Codex model page — https://developers.openai.com/api/docs/models/gpt-5.1-codex
4. OpenAI, API pricing — https://developers.openai.com/api/docs/pricing
5. OpenAI, Codex CLI — https://developers.openai.com/codex/cli
6. OpenAI, Codex permissions — https://developers.openai.com/codex/permission-modes
7. OpenAI, “Introducing the Codex app” — https://openai.com/index/introducing-the-codex-app/
8. Anthropic, Models overview — https://platform.claude.com/docs/en/models/overview
9. Anthropic, Pricing — https://platform.claude.com/docs/en/about-claude/pricing
10. Claude, Pricing plans — https://claude.com/pricing
11. Claude Code, Overview — https://code.claude.com/docs/en/overview
12. Claude Code, Manage costs effectively — https://code.claude.com/docs/en/costs
13. GitHub Docs, Plans for GitHub Copilot — https://docs.github.com/en/copilot/get-started/plans
14. GitHub Docs, Models and pricing for GitHub Copilot — https://docs.github.com/copilot/reference/copilot-billing/models-and-pricing
15. GitHub Docs, Usage-based billing for individuals — https://docs.github.com/en/copilot/concepts/billing-and-usage/individuals/billing
16. Cursor, Pricing — https://cursor.com/pricing
17. Cursor Docs, Models & Pricing — https://cursor.com/docs/models-and-pricing
18. Cursor Docs, Cursor Router — https://cursor.com/docs/cursor-router
19. Cursor Docs, Tab — https://cursor.com/docs/tab/overview
20. Cursor Docs, Cloud Agents — https://cursor.com/docs/cloud-agent
21. Devin Docs, Introducing Devin Desktop — https://docs.devin.ai/desktop
22. Devin Docs, AI Models (Desktop) — https://docs.devin.ai/desktop/models
23. Devin Docs, Adaptive — https://docs.devin.ai/cli/adaptive; Fusion — https://docs.devin.ai/cli/fusion
24. Devin Docs, Self-serve plans — https://docs.devin.ai/admin/billing/self-serve
25. Pi Docs, Overview — https://pi.dev/docs/latest; Quickstart — https://pi.dev/docs/latest/quickstart; Providers — https://pi.dev/docs/latest/providers; How Pi Works — https://pi.dev/docs/latest/how-pi-works
26. OpenCode Docs, Intro — https://opencode.ai/docs/; Agents — https://opencode.ai/docs/agents/; Go — https://opencode.ai/v2/docs/console/go/
27. SWE-bench — https://www.swebench.com/
28. LiveCodeBench — https://livecodebench.github.io/
29. Terminal-Bench — https://www.tbench.ai/
30. Google DeepMind, Gemini — https://deepmind.google/models/gemini/