Amp

Sourcegraph spent a decade solving one problem: understanding very large codebases well enough to answer questions about them. Code search, cross-repository references, the tooling that lets an engineer at a big company find every caller of a function across millions of lines.

That turns out to be the exact capability agentic coding needs and mostly lacks. A frontier model can write excellent code; what it cannot do is know what else in your repository depends on the thing it is about to change.

Amp is what happens when the second problem is solved by a company that already solved the first. That lineage is the main reason to take it seriously, and the pricing posture — provider cost, no markup — is the second.

What Is Amp, In One Screen?

• An agentic coding tool from Sourcegraph, running in the terminal and in editor extensions including VS Code and compatible forks.
• Sourcegraph's code intelligence is the differentiator — it gives frontier models real repository context rather than whatever fits in a window.
• It plans and iterates: multi-step task planning, edits across the codebase, running tests, reading the output and trying again.
• Threads let you save and share a session, which turns an agent run into something a colleague can review.
• Pay-as-you-go at provider cost with no markup, plus a free ad-supported tier with no hard token caps and no card required.

Why Code Intelligence Beats A Bigger Context Window

The industry's default answer — including in Cursor — has been to make context windows larger and paste in more files. Amp's approach is different, and better suited to how code actually works.

Code is a graph, not a document. What matters about a function is not the text near it but what calls it, what it calls, what types flow through it and what tests cover it — and those live in files scattered across the tree. Pasting in adjacent text gives a model proximity rather than relevance.

Sourcegraph's code intelligence resolves those relationships properly, which means the model can be given the specific definitions and call sites that bear on a change rather than a large sample of nearby code and a hope.

The practical consequence shows up on exactly the tasks that matter most and demo least well: multi-file refactors, changing a shared interface, renaming something used in forty places. Those are the changes engineers avoid because they are tedious and risky, and they are where an agent with real reference data earns its cost.

The complementary limitation is worth stating. Code intelligence is strongest where a language has good static analysis. Dynamically typed code with heavy runtime magic resolves less cleanly, for the same reasons your IDE struggles with it — the references genuinely are harder to determine.

A model given the file next door has proximity. A model given every actual caller has relevance. Only the second one can refactor safely.

Threads Make An Agent Run Reviewable

Amp's Threads feature saves and shares interactions, and this is more consequential than a convenience feature.

The problem it addresses is that agentic sessions are currently invisible work. A colleague sees the resulting pull request but not the eleven steps, the two wrong turns and the reasoning that produced it. When something is subtly wrong, nobody can reconstruct how it happened.

A shareable thread turns that into a reviewable artefact. Another engineer can read the sequence, see where the agent misunderstood the requirement, and correct the prompt rather than the code.

It also has an underrated teaching use. The fastest way for a team to get good at agentic coding is to read sessions that worked, and threads make that shareable rather than each person rediscovering the technique privately.

What Does No Markup Actually Mean?

Amp charges pay-as-you-go credits with zero markup on provider API pricing for individuals, alongside a free tier that requires no card.

This is a materially different posture from the seat subscriptions that dominate the category, and it is worth understanding what it implies about incentives.

A seat subscription is a bet by the vendor that you will use less than you pay for. That creates a quiet incentive to make heavy usage inconvenient, and it means light users subsidise heavy ones. Charging provider cost inverts it: the vendor makes nothing on your token consumption, so there is no reason to ration it, and no reason to route you to a cheaper model than the task deserves.

For a user the consequences are concrete. A month you barely code costs almost nothing. A month spent on a large migration costs what that migration's model usage actually cost, which may be more than a subscription would have — and you can see exactly why.

The trade is budgeting. Finance departments prefer a predictable line item, and a variable one is harder to approve even when it is cheaper on average. If your organisation needs a fixed number, this model will be an argument rather than a feature.

• Light or uneven usage is cheaper here than under any per-seat plan.
• A heavy migration month may cost more than a subscription, and you will see precisely why.
• No incentive exists to route you to a weaker model, since the vendor takes no margin on tokens.
• Variable spend is harder to get approved than a flat fee, whatever the average works out to.
• Watch the first two weeks of real usage before assuming which model suits you.

The Free Tier Is Ad-Supported, And That Matters

Amp's free tier includes its Tab autocomplete, access to the core agent with no hard token caps, and thread sharing — and it is ad-supported.

Take the generosity seriously first: a free tier with no hard token cap on the core agent is unusual, and it means the tool can be evaluated properly rather than through a crippled trial.

The ad-supported model deserves plain treatment though, because it is uncommon in developer tooling and people have reasonable questions about it. The relevant question is not whether ads are annoying; it is what they imply about data.

The paid tier is described as offering zero data sharing, with code, prompts and agent threads not used to train models. Read the inverse carefully: if that is the differentiator, then the free tier does not carry the same guarantee.

For personal projects and open-source work that may be entirely acceptable. For employer code it usually is not, and the decision should be made deliberately rather than by defaulting to the free tier because it was there. If your code is proprietary, the paid tier is the only sensible starting point, and the pricing model makes that a small step rather than a big one.

Trying Amp On Work You Have Already Done

The free tier makes evaluation easy, but evaluate it on the task type that distinguishes it rather than on the one that is easiest to test.

The bar is step three. Single-file edits tell you nothing about Amp specifically, because every agent in the category handles those.

1. Decide the tier question before you start: personal or open-source code can go on the free tier, employer code should not.
2. Pick a refactor you have already completed — a renamed interface, a changed function signature, something touching many files.
3. Ask Amp to do it and check whether it found every call site. This is the code intelligence test and the whole reason to choose this tool.
4. Read the thread rather than only the diff. The steps show you where it understood the task and where it guessed.
5. Share that thread with a colleague and see whether they can follow it, since reviewability is a genuine differentiator here.
6. Check your credit consumption for the session and extrapolate to a realistic month, because pay-as-you-go is invisible until you look.

Where Amp Sits Against Its Siblings

Amp competes in a crowded category, and the honest summary is that the differences are narrowing on code generation and widening on everything around it.

Against an editor-first tool, Amp gives up ambient context — it does not know what you have selected or which test just failed — and gains repository-scale reference data plus the ability to run in a terminal, in CI or over SSH.

Against an open-source terminal agent such as Aider, it gives up model flexibility and full local operation, and gains Sourcegraph's code intelligence, which is a genuinely hard thing to replicate.

Against an enterprise orchestration platform such as Zencoder, it gives up compliance certifications, on-premise deployment and administrative controls, and gains simplicity and a pricing model that does not require a procurement process.

The buyer this suits best is a developer or a small team working in a large or complex codebase, who wants an agent with real reference data and does not need a compliance conversation to adopt one.

Amp: The Stated Specification

Which Developers Amp Suits

Well matched when

• You work in a large or complex codebase where knowing every caller is the hard part of a change.
• Your usage is uneven, and paying provider cost beats a seat you sometimes do not use.
• You want agent sessions your colleagues can read and learn from rather than opaque pull requests.
• You want to run an agent in a terminal, in CI or over SSH rather than only inside an editor.
• You would rather choose the model per task than accept whichever one a vendor bundled.

A poor match when

• Your finance process needs a fixed monthly figure, which pay-as-you-go cannot give you.
• Your code is proprietary and you intended to use the free tier, which is ad-supported and does not carry the paid tier's data guarantee.
• You need compliance certifications or on-premise deployment, which this does not advertise.
• Your codebase is small, where repository-scale code intelligence solves a problem you do not have.
• You need the agent to see your selection and failing tests, which is an editor-first strength.