Searches for “amp code” jumped hard in August 2026, and most of the people typing it are not asking about electrical current. They are trying to figure out what happened to Sourcegraph’s coding agent, why it suddenly has a $200-a-month tier called Gigawatt, and whether it is worth switching to from Cursor or Claude Code. Amp vs Claude Code vs Cursor is the comparison developers actually need right now, because all three took very different bets on what an AI coding agent should look like in 2026, and the gap between those bets shows up directly in your monthly bill and in how each tool handles a codebase with more than a handful of files.
This is not a rehash of the Cursor-vs-everyone debate. Amp Code spun out of Sourcegraph as its own company, Amp Frontier Corporation, in December 2025, led by Sourcegraph co-founder Quinn Slack, and it has spent 2026 rebuilding its pricing around a genuinely unusual model: pass-through API billing with zero markup, sitting alongside flat monthly subscriptions. Claude Code, meanwhile, keeps climbing independent benchmark leaderboards. Cursor keeps its lead in raw adoption. None of the three are chasing the same thing, and that makes this a real three-way decision rather than a popularity contest.
Below: full specs, pricing pulled from each vendor’s own pages, SWE-bench figures from three separate reporting sources, five real deployment scenarios, a setup guide for all three tools, and a verdict that does not pretend there is one correct answer for every team.
Why Amp Code Is Suddenly Everywhere in Developer Search
Amp Code did not appear out of nowhere. It launched in May 2025 as Sourcegraph’s first fully agent-native coding environment, built by the same team that made Sourcegraph’s code search engine and its earlier Cody assistant. What changed in the second half of 2025 and through 2026 is the business structure and the pricing model around it, and that is what is driving the current spike in search interest.
Sourcegraph spun Amp out as an independent company, Amp Frontier Corporation, in December 2025, with Sourcegraph co-founder Quinn Slack leading the new entity. Before that, Amp had already tried an unusual go-to-market move: on October 15, 2025, it launched “Amp Free,” an entirely ad-supported free tier funded by targeted ads and data sharing rather than a subscription. That free tier is now closed to new signups as of mid-2026, though existing users reportedly kept access to roughly $10 a day in free agent credits.
The bigger shift landed in July 2026, when Amp introduced paid subscription tiers, Megawatt and Gigawatt, on top of its existing usage-based billing. That combination, a flat monthly plan plus an option to pay exact LLM provider cost with no markup, is not something Cursor or Claude Code offers in the same form, and it is the single biggest reason “amp code” and “amp code pricing” have become searches worth answering properly rather than a footnote in a bigger roundup.
What Is Amp Code, Exactly?
Amp Code describes itself as a frontier agent and development environment built around three core concepts: Threads, Orbs, and a terminal-based interface it calls the Amp TUI. Threads are persistent, resumable agent conversations tied to a task, similar in spirit to a long-running pull request discussion but driven by an AI agent instead of a human reviewer. Orbs are Amp’s mechanism for running multiple agent tasks in parallel in the background, letting a developer kick off several independent changes at once instead of babysitting one linear session.
Unlike Cursor and Claude Code, Amp is generally described in current documentation and reviews as model-agnostic rather than tied to a single flagship model. Amp’s TUI acts as a client and router: a developer configures their own model provider and API key, whether that is Anthropic, OpenAI, or another compatible provider, and Amp forwards agent requests to that backend rather than shipping one fixed in-house model the way Cursor’s Composer does. That design choice is also why Amp does not publish its own SWE-bench score the way Cursor and Anthropic do, since its output quality depends on whichever model a given team has wired into it.
Amp’s own product updates through the summer of 2026 have focused on developer productivity details rather than headline features: live reloading so a developer can test agent changes without restarting a session, expanded file upload support, reduced operational cost for running Orbs in parallel, and event-driven triggers for kicking off agent tasks automatically. None of that is flashy, but it is consistent with Amp’s positioning as a tool for large, complex codebases where the bottleneck is navigating and understanding code, not generating a single function from scratch.
Amp vs Claude Code vs Cursor: Specs at a Glance
The table below lines up what each tool actually is, how it is built, and how it reaches an AI model, based on each vendor’s own documentation and pricing pages as of late August 2026.
| Spec | Amp Code | Claude Code | Cursor |
|---|---|---|---|
| Maker | Amp Frontier Corporation (spun out of Sourcegraph, Dec 2025) | Anthropic | Anysphere, an independent company |
| Primary interface | Terminal UI (TUI), agent-native, no full standalone editor GUI | Terminal / CLI, integrates into existing editors and CI pipelines | Full VS Code-fork editor with Composer agent panel |
| Underlying model | Model-agnostic, user supplies provider and API key | Claude Opus 5 (Anthropic’s own frontier model) | Own Composer model, plus Claude, GPT, and Gemini options |
| Core workflow concepts | Threads (persistent tasks), Orbs (parallel background agents) | Terminal sessions, scriptable automation, CI/CD hooks | Composer (multi-file agent), Agent Mode, Tab autocomplete |
| Best fit | Large monorepos, cross-service code search and navigation | Terminal-first workflows, automation, CI/CD tasks | In-editor refactoring, visual coding, front-end work |
| Free tier | Amp Free, ~$10/day credits (closed to new signups mid-2026) | None separate; Claude Code ships with paid Claude plans | Hobby, $0, 50 fast requests as a trial |
| Entry paid tier | Megawatt, $20/month | Included with Claude Pro, $20/month | Pro, $20/month ($16/month billed annually) |
| Top individual tier | Gigawatt, $200/month, $200 of included agent usage | Max 20x, $200/month | Ultra, $200/month |
| Usage-based option | Pay-as-you-go, exact provider cost, 0% markup, $5 minimum | Not offered separately; bundled into plan tiers | Not offered separately; bundled into fast-request quotas |
| Enterprise pricing | ~50% above individual/team rate, $1,000 minimum start, SSO and zero-retention | Custom, via Anthropic enterprise plans | Custom, Teams from $40/seat, Teams Premium $120/seat |
| Open source | No | No | No |
The single most important line in that table is the underlying model row. Cursor and Claude Code each bet on a specific model experience, Cursor’s own Composer or Anthropic’s Claude Opus 5, while Amp Code deliberately stays out of the model business and instead competes on billing transparency and how well it navigates large, messy codebases.
What Claude Code Offers in 2026
Claude Code is Anthropic’s terminal-based coding agent, built to live in a developer’s shell rather than inside a dedicated editor GUI. It is not sold as a standalone product; instead, it ships bundled into Claude’s existing consumer and business plans, checked directly against Anthropic’s own pricing page as of August 19, 2026. Claude Pro at $20 a month (or roughly $17 a month billed annually) includes Claude Code access at Pro-tier usage limits. Max 5x at $100 a month and Max 20x at $200 a month give Claude Code the same usage multiplier as the rest of the plan, five times and twenty times Pro’s capacity respectively.
Claude Code’s biggest 2026 headline is a benchmark number. According to Morph’s August 2026 comparison of AI coding agents, Claude Code running Claude Opus 5 leads the independent vals.ai SWE-bench Verified leaderboard at 97.0%, the highest score reported on that board as of the article’s August 21, 2026 publish date. That is a sharp jump from earlier 2026 figures, where Claude Code with Opus 4.6 scored around 80.8% in benchmarks reported in the spring, and Opus 4.7 reached the mid-80s by April and May. The trajectory itself is the story: Anthropic has been closing the gap toward near-saturation on this particular benchmark faster than either of its two closest rivals in this comparison.
Because Claude Code lives in the terminal rather than a GUI editor, it fits naturally into CI/CD pipelines, scripted automation, and workflows where a developer wants an agent to run as part of a build step or a scheduled job rather than as an interactive chat panel. That is also its main limitation for teams that want a visual, point-and-click refactoring experience, since Claude Code has no native file-tree browser or diff viewer of its own, and typically depends on whatever terminal, editor, or CI system it is invoked from.
What Cursor Offers in 2026
Cursor remains the most editor-centric of the three tools compared here, built as a full VS Code fork with Composer, its multi-file agent, integrated directly into the interface. Cursor Pro costs $20 a month on monthly billing, or $16 a month billed annually, and includes 500 fast model requests per month plus unlimited slower requests, according to Cursor’s own pricing page and independent reviews published in July 2026. The free Hobby tier gives new users 50 fast requests as a trial before they hit a wall. Cursor Business runs $40 per seat per month, with the same 500 fast-request allowance applied per user rather than pooled across a team.
On the benchmark side, Cursor’s reported SWE-bench Verified score sits at 51.7%, a figure that has held steady across multiple comparison pieces published through the first half of 2026. That is a meaningfully different number from Claude Code’s 97.0%, but it measures a different thing in practice: SWE-bench Verified tests whether an agent can autonomously resolve real GitHub issues end to end, while Cursor’s Composer 2.5 release in April 2026 was benchmarked separately at 79.8% on SWE-bench Multilingual, a different suite that tests cross-language code editing rather than autonomous issue resolution. The two benchmarks are not directly comparable, and Cursor’s own marketing tends to lead with the Multilingual figure rather than the Verified one for that reason.
What Cursor consistently wins on is day-to-day editor experience. Its extension compatibility with the VS Code marketplace, its in-line diff review, and its Tab autocomplete for smaller completions make it the most approachable of the three tools for a developer who does not want to leave a familiar GUI, even if the underlying agent is not the top scorer on every benchmark.
Benchmark Results Compared: What the Numbers Actually Measure
Benchmark comparisons across these three tools are genuinely tricky, because Amp Code does not publish a benchmark score at all, and Claude Code and Cursor were measured on different SWE-bench variants at different points in 2026. The table below lays out every figure found, with its source and date, rather than forcing them into a false apples-to-apples ranking.
| Tool / Model | Benchmark | Score | Source and date |
|---|---|---|---|
| Claude Code (Claude Opus 5) | SWE-bench Verified (vals.ai independent leaderboard) | 97.0% | Morph comparison, published Aug 21, 2026 |
| Claude Code (Claude Opus 4.6, earlier 2026) | SWE-bench Verified | 80.8% | Spring 2026 comparison reviews |
| Cursor (Composer, current) | SWE-bench Verified | 51.7% | Tech-Insider comparison, published Jun 4, 2026, updated Jun 26, 2026 |
| Cursor (Composer 2.5) | SWE-bench Multilingual | 79.8% | Cursor release coverage, Apr 15, 2026 |
| Reference: Claude Opus 4.7 on the same Multilingual run | SWE-bench Multilingual | 80.1% | Cursor release coverage, Apr 15, 2026 |
| Amp Code | Not published | N/A | No SWE-bench or comparable score found in Amp’s product materials as of Aug 2026 |
Read this table carefully rather than skimming the top row. SWE-bench Verified tests full, autonomous issue resolution against real GitHub repositories, so Claude Code’s 97.0% and Cursor’s 51.7% describe the same test. SWE-bench Multilingual is a separate benchmark focused on cross-language editing accuracy, so Cursor’s 79.8% there is not a lower or higher version of its 51.7% Verified score, it is a different measurement entirely. Amp Code’s absence from this table is not an oversight, it reflects Amp’s actual design: since it routes to whatever model a team configures, a single benchmark score for “Amp” would only describe one specific model pairing, not the product itself.
Pricing Compared: Free Tier to Enterprise
Pricing structure, not just the sticker price, is where these three tools diverge the most. Amp Code is the only one of the three offering true pass-through billing with no markup on top of raw model cost.
| Plan tier | Amp Code | Claude Code (via Claude plans) | Cursor |
|---|---|---|---|
| Free / entry tier | Amp Free, ~$10/day credits (closed to new signups) | Not offered standalone | Hobby, $0, 50 fast requests |
| Entry paid plan | Megawatt, $20/month | Claude Pro, $20/month ($17/month annual) | Pro, $20/month ($16/month annual) |
| Mid tier | Not applicable | Max 5x, $100/month | Not applicable |
| Top individual tier | Gigawatt, $200/month, $200 included usage | Max 20x, $200/month | Ultra, $200/month |
| Usage-based billing | Pay-as-you-go, 0% markup on provider cost, $5 minimum purchase | Not offered separately | Not offered separately |
| Team pricing | Usage-based, no flat per-seat fee | Business/Enterprise, custom via Anthropic | Teams, $40/seat/month; Teams Premium $120/seat/month |
| Enterprise entry cost | $1,000 one-time purchase grants $1,000 of usage, then ~50% above standard rate | Custom quote | Custom quote |
The practical takeaway: if your team already knows exactly how many tokens a typical sprint burns through, Amp’s pay-as-you-go option can be cheaper than any flat subscription in this comparison, since you pay Anthropic’s or OpenAI’s list price with nothing added on top. If your usage is unpredictable or heavy, a flat $200 Gigawatt, Max 20x, or Ultra plan caps the downside in a way pure usage billing cannot.
Five Real-World Scenarios: Which Tool Wins
1. A fintech company with a 40-service microservices monorepo
When the hard problem is finding where a change needs to happen across dozens of services rather than writing the change itself, Amp Code’s Threads and cross-repo code intelligence, inherited from Sourcegraph’s original code search engine, are the strongest fit among the three. Teams in this situation often care more about accurate navigation than about topping a benchmark leaderboard.
2. A platform team automating code fixes inside CI/CD
Claude Code’s terminal-native design and its 97.0% SWE-bench Verified score make it the obvious choice for a team that wants an agent triggered from a GitHub Action or a scheduled pipeline job, resolving flagged issues without a human opening an editor at all.
3. A front-end team doing visual, in-editor refactors
Cursor’s Composer, tab autocomplete, and full VS Code-compatible extension ecosystem remain the best fit for developers who want to see a diff, click to accept or reject it, and stay inside one familiar GUI all day.
4. A cash-conscious startup with unpredictable AI usage
Amp Code’s pay-as-you-go billing, with zero markup on the underlying model cost and only a $5 minimum purchase, lets a small team pay for exactly what they use in a slow month without committing to a $20 or $200 flat plan they might not fully use.
5. An enterprise that needs SSO and zero data retention
Both Amp Code’s enterprise tier, with its SSO and zero-retention features layered on top of usage-based pricing, and Claude Code’s enterprise plans through Anthropic address this need directly, while Cursor’s Teams Premium tier at $120 per seat per month targets the same compliance-conscious segment from the editor side.
Migration Guide: Setting Up Amp, Claude Code, or Cursor
Setting up Amp Code
- Sign up at ampcode.com and choose Megawatt, Gigawatt, or pay-as-you-go billing depending on your expected usage volume.
- Install the Amp TUI in your terminal and authenticate your account.
- Configure your model provider and API key, since Amp is model-agnostic and needs to know which backend, such as Anthropic or OpenAI, to route requests to.
- Open a Thread against your primary repository and let Amp’s code intelligence index the codebase before assigning your first real task.
- Use Orbs to run two or three low-risk background tasks in parallel, such as generating tests for separate modules, before trusting Amp with a cross-service change.
- If evaluating for a team, start on pay-as-you-go billing for the first month to measure real token usage before committing to Megawatt or Gigawatt.
Setting up Claude Code
- Subscribe to Claude Pro, Max 5x, or Max 20x at claude.com/pricing depending on expected usage, since Claude Code is bundled into these plans rather than sold separately.
- Install the Claude Code CLI in your terminal and authenticate with your Claude account.
- Run Claude Code inside your project directory and grant it the file and shell permissions it needs for your workflow.
- Wire Claude Code into a CI/CD step or GitHub Action if your goal is automated issue resolution rather than interactive use.
- Start with a Pro plan and a low-risk automation task, then upgrade to Max 5x or Max 20x once you have a clear sense of how much usage your automation actually consumes.
Setting up Cursor
- Download Cursor from cursor.com and import your existing VS Code settings, keybindings, and extensions during first launch.
- Connect your Git provider and open your primary repository, letting Cursor complete its initial codebase index.
- Choose which models are available inside Composer, since Cursor supports its own model plus Claude, GPT, and Gemini options.
- Start on the free Hobby tier to test the workflow, then move to Pro once you exceed the 50 fast-request trial allowance.
- For teams, evaluate whether the standard Teams seat at $40/month or the higher-usage Teams Premium seat at $120/month matches your expected request volume before rolling it out company-wide.
A minimal Amp configuration file that points the TUI at a specific model provider looks like this:
{
"provider": "anthropic",
"model": "claude-opus-5",
"api_key_env": "ANTHROPIC_API_KEY",
"billing_mode": "pay-as-you-go",
"orbs": {
"max_parallel": 3
}
}Because Amp is model-agnostic, swapping the provider and model fields is enough to route the same Threads and Orbs workflow to a different backend without changing anything else about how the team works.
Pros and Cons
Amp Code
- Pro: Zero-markup, pass-through billing on usage-based plans, a rare pricing structure among AI coding agents.
- Pro: Strong code search and cross-repo navigation, inherited from Sourcegraph’s original code intelligence engine.
- Pro: Model-agnostic, so it is not locked to one vendor’s model roadmap or pricing changes.
- Con: No published benchmark scores, making it harder to evaluate raw coding accuracy against Claude Code or Cursor.
- Con: Terminal-only interface, with no full GUI editor for developers who prefer a visual workflow.
- Con: Free tier is closed to new signups as of mid-2026.
Claude Code
- Pro: Leads the independent vals.ai SWE-bench Verified leaderboard at 97.0% as of August 2026.
- Pro: Bundled into existing Claude subscriptions, so no separate purchase decision for current Claude users.
- Pro: Strong fit for CI/CD automation and scripted, terminal-first workflows.
- Con: No standalone pricing, tying access to a broader Claude plan whether or not you need the rest of it.
- Con: No native GUI, file tree, or diff viewer of its own.
- Con: Locked to Anthropic’s own models, with no option to route to GPT or Gemini.
Cursor
- Pro: Full VS Code-compatible editor with the largest extension ecosystem of the three tools.
- Pro: Multi-model support across its own Composer, Claude, GPT, and Gemini.
- Pro: Most approachable for developers who want a visual, point-and-click AI workflow.
- Con: Lower SWE-bench Verified score, at 51.7%, than Claude Code’s 97.0%.
- Con: Closed source and now owned by SpaceX, an unusual corporate parent for a developer tool.
- Con: Fast-request quotas on Pro and Business plans can run out during heavy agentic sessions.
The Business Model Shift Behind This Comparison
It is worth stepping back and asking why billing structure has become such a big part of the AI coding tool conversation in 2026, when a year earlier most of the debate was purely about model quality. The answer is that flat-rate AI subscriptions turned out to be expensive to run at scale, and vendors have been adjusting in opposite directions. Cursor widened its tier spread, adding Pro+ at $60 a month between its existing Pro and Ultra plans, effectively admitting that a single $20 plan could not cover both light and heavy users profitably. Amp went the other way, building its entire pitch around exact-cost, zero-markup billing as an alternative to guessing which flat tier fits a given team’s usage pattern.
Claude Code sidestepped the question entirely by never selling itself as a standalone product with its own pricing page. Bundling it into the broader Claude Pro, Max 5x, and Max 20x plans means Anthropic does not have to solve the “how much does one developer’s agent usage really cost us” problem in isolation, since Claude Code usage counts against the same limits a subscriber already has for chat and other Claude features. That is convenient for existing Claude users and slightly opaque for anyone trying to budget for Claude Code specifically, separate from everything else in the plan.
For a team picking between these three tools in late 2026, the billing model is no longer a minor detail buried at the bottom of a comparison. It is a direct signal of how each company expects usage to scale. Amp’s bet is that developers increasingly want to see exactly what they are paying for at the API-call level. Cursor’s bet is that most developers will pick a flat tier and rarely think about it again, as long as the tiers are granular enough to avoid sticker shock. Anthropic’s bet is that bundling Claude Code into a broader subscription reduces the number of purchase decisions a developer has to make, at the cost of making Claude Code’s specific value harder to isolate on a bill.
What Switching Actually Looks Like in Week One
Comparisons like this one tend to understate how disruptive a first week with a new AI coding agent actually is, regardless of which of the three tools a team picks. The biggest adjustment with Amp Code is cultural rather than technical: since it lives entirely in the terminal, engineers who have spent the last two years getting comfortable with Cursor’s or Copilot’s in-editor chat panels have to relearn how to describe a task in a Thread rather than pointing at a highlighted block of code. Teams that have made this switch successfully tend to start with a single senior engineer running Amp on a well-understood part of the codebase for a week before rolling it out further, specifically because Threads and Orbs behave differently enough from a chat sidebar that a rushed team-wide rollout tends to produce confused feedback in the first few days.
Claude Code’s first week looks different again, since most of the setup work is really about deciding where in a pipeline the agent should run rather than how a human should talk to it. Teams that get the most value early tend to pick one narrow, well-defined automation, such as auto-generating changelog entries or resolving flagged lint violations, rather than immediately pointing Claude Code at open-ended feature work. Cursor’s onboarding is the smoothest of the three precisely because it does not require a new mental model at all: a developer who already knows VS Code can be productive inside Cursor within an hour, with Composer feeling like an extension of autocomplete rather than a separate tool to learn.
None of this means one onboarding curve is objectively better than another, but it does mean the migration cost of each tool should factor into a decision alongside pricing and benchmarks. A five-person startup can absorb a bumpy first week with Amp’s terminal-first workflow far more easily than a 200-engineer organization can, where a confusing rollout produces a much louder wave of internal complaints and a slower path back to a working default.
Where GitHub Copilot Still Fits Into This Comparison
None of these three tools operate in a vacuum, and GitHub Copilot remains the default many developers already have access to through an existing enterprise GitHub license. Copilot’s advantage is not raw benchmark performance, it is that it is already installed for a large share of engineering organizations and integrates directly into GitHub’s pull request review flow. Teams evaluating Amp Code, Claude Code, or Cursor should treat Copilot as the baseline they are trying to beat, not as a fourth option in this specific comparison, since its strengths (ubiquity, PR integration) and weaknesses (shallower codebase context than any of the three tools above) are well documented elsewhere.
Security, Billing Transparency, and Vendor Risk
Billing transparency turns out to be a real security and budgeting question, not just a pricing footnote. Amp’s zero-markup, pass-through model means a finance team can audit exactly what was spent on which model calls, since there is no hidden margin baked into the number. Claude Code and Cursor both bundle usage into flat plans or request quotas, which is simpler to budget for but harder to audit down to the individual API call.
On vendor risk, Cursor carries the most exposure of the three following its acquisition by SpaceX, since a developer tool now sits inside a company whose primary business is aerospace, not software. Claude Code’s risk is more conventional vendor lock-in, since it only works with Anthropic’s own models and pricing changes. Amp’s model-agnostic design is the one structural hedge against this kind of risk in this comparison: if a team’s chosen model provider changes its terms, only the configuration file needs to change, not the whole toolchain.
Which Tool Should You Choose: Recommendations by Use Case
- Choose Amp Code if you work in a large monorepo or multi-service codebase where finding the right place to make a change is harder than writing the change, or if you want transparent, zero-markup billing.
- Choose Claude Code if your priority is the highest available coding-agent benchmark score and you already live in the terminal or want to wire an agent into CI/CD automation.
- Choose Cursor if you want a full visual editor experience with the broadest model choice and the largest extension ecosystem of the three.
- Choose a hybrid setup if your team has both a platform group focused on large-scale refactors, better served by Amp, and a product engineering group doing day-to-day feature work, better served by Cursor.
- Stick with GitHub Copilot for now if your organization has not yet budgeted for a second AI coding tool and needs to justify the switch with a clear cost or capability gap first.
The Verdict
On pure benchmark performance, Claude Code’s 97.0% SWE-bench Verified score is not close to Cursor’s 51.7%, and Amp Code does not compete on that axis at all by design. But benchmark performance is not the same question as “which tool should my team buy,” and the honest answer splits three ways depending on what actually slows your team down. If it is navigating a codebase, Amp wins. If it is autonomous issue resolution at the highest possible accuracy, Claude Code wins. If it is a visual, familiar editor experience with model flexibility, Cursor wins.
The most interesting number in this whole comparison may not be a benchmark at all, it is Amp’s $5 minimum purchase and 0% markup on usage billing. That pricing structure did not exist in this category a year ago, and its arrival in July 2026 suggests that at least one serious competitor thinks the next battleground in AI coding tools is billing transparency, not just model quality.
How This Comparison Was Put Together
Pricing details for Amp Code were checked against Amp’s official site, with background on its Sourcegraph origins from Sourcegraph’s own site. Claude Code pricing and positioning came from Anthropic’s Claude Code page and Claude’s pricing page. Cursor pricing was verified against Cursor’s official pricing page. Benchmark methodology referenced throughout, including the SWE-bench Verified and SWE-bench Multilingual suites, is documented at swebench.com.
Developers comparing AI coding agents more broadly may also find our breakdowns of Claude Code vs Cursor, Claude Code vs GitHub Copilot, and Codex vs Cursor vs Claude Code useful for adjacent tooling decisions. Teams evaluating lighter-weight or open-source agent options may also want to review OpenCode vs Claude Code and Cline vs Claude Code, since both take a different approach to the cost-versus-capability tradeoff covered here.
Frequently Asked Questions
What is Amp Code and who makes it?
Amp Code is an AI coding agent and development environment originally built by Sourcegraph, launched in May 2025. It spun out as an independent company, Amp Frontier Corporation, in December 2025, led by Sourcegraph co-founder Quinn Slack.
Is Amp Code the same as AWS Amplify?
No. Amp Code is an AI coding agent unrelated to AWS Amplify, which is Amazon’s framework for building and hosting web and mobile applications. The two share no corporate or technical relationship.
How much does Amp Code cost?
Amp offers a Megawatt subscription at $20 a month and a Gigawatt subscription at $200 a month with $200 of included agent usage, plus a pay-as-you-go option that charges the exact underlying model provider cost with a 0% markup and a $5 minimum purchase. Its earlier ad-supported Amp Free tier is closed to new signups as of mid-2026.
Does Amp Code use Claude or GPT models?
Amp Code is generally described as model-agnostic. Rather than shipping one fixed in-house model, it routes agent requests to whichever provider and model a user configures, such as Anthropic or OpenAI, using that provider’s own API key.
Which scores higher on SWE-bench, Claude Code or Cursor?
Claude Code, running Claude Opus 5, leads the independent vals.ai SWE-bench Verified leaderboard at 97.0% as of an August 21, 2026 report. Cursor’s most recently reported SWE-bench Verified score is 51.7%. Cursor also publishes a separate SWE-bench Multilingual score of 79.8% for its Composer 2.5 release, which measures a different task and should not be directly compared to the Verified figure.
Can I use Claude Code without paying for a full Claude subscription?
No. Claude Code is not sold as a standalone product. It is bundled into Claude Pro at $20 a month, Max 5x at $100 a month, and Max 20x at $200 a month, and access requires one of those paid plans.
Is Amp Code better than Cursor for large codebases?
Amp Code is generally positioned for large monorepos and cross-service code search, inheriting Sourcegraph’s original code intelligence engine, while Cursor is built around an in-editor, visual refactoring experience. Teams whose main bottleneck is finding the right place to make a change across many services tend to favor Amp, while teams doing focused, file-level editing tend to favor Cursor.
What is the cheapest way to try an AI coding agent from this comparison?
Amp’s pay-as-you-go billing, with its $5 minimum purchase and zero markup on model cost, is the lowest-commitment way to test an AI coding agent from this group, since it does not require a monthly subscription. Cursor’s free Hobby tier, with 50 fast requests, is the best no-cost trial option if you want a full GUI editor rather than a terminal tool.