Sourcegraph Amp

Sourcegraph Amp is an autonomous coding agent that pairs agentic task execution with Sourcegraph's decade of codebase indexing and code intelligence. It targets enterprise teams with large, complex codebases where context quality is the limiting factor for AI coding tools.

Most AI coding agents hit a wall around 50,000 lines of code. The context window fills up, the model starts losing track of which module owns which responsibility, and suggestions start contradicting each other. For individual developers on small projects this rarely matters. For engineering teams running a 2-million-line monorepo across forty services, it's the reason most AI tools feel promising in a demo and frustrating in production.

Sourcegraph has spent over a decade building infrastructure to make code at that scale searchable and understandable. Amp is what happens when you attach an autonomous coding agent to that infrastructure. It's a different starting point than Cursor or Claude Code, and for the right kind of team, it's a meaningfully different result.

Quick verdict

If you're an individual developer on a normal-sized project, Amp is probably not the tool you need first. Cursor or Claude Code will serve you better for typical use cases. If you're on a platform team dealing with a large, multi-repository codebase and you've already felt the limits of other AI coding tools on your specific scale of code, Amp is worth a serious evaluation. The code intelligence layer is genuinely differentiated, and the enterprise positioning is more than marketing.

What Sourcegraph Amp is

Sourcegraph launched Amp in May 2025 as a product separate from their older assistant Cody. The confusion between the two is understandable: both come from Sourcegraph, both help developers work with AI on code. The distinction is the problem each one solves.

Cody is an AI assistant that lives in your IDE and helps with completions and chat. Amp is an autonomous agent that executes multi-step coding tasks. Think of Cody as the AI layer on top of your editor and Amp as the AI system that runs the bigger jobs, the migrations, the cross-service refactors, the tasks that require understanding how ten modules interact before you can safely change any of them.

The product lives at ampcode.com, integrates with VS Code and JetBrains, and supports multiple AI models including Claude Sonnet and Opus, GPT-4o, and Gemini. You can route different task types to different models, a pattern that's become standard across good agentic tools.

What makes Amp distinct is what sits behind it. Sourcegraph's code intelligence indexes your entire codebase, builds a graph of symbol references, call chains, and cross-file relationships, and keeps that graph current as your code changes. When Amp needs to understand the impact of changing a function signature, it isn't guessing from embeddings. It has a precise dependency graph. That precision is the thing that makes a difference at enterprise scale.

The features worth understanding

Code intelligence as the foundation

Sourcegraph has a code graph, not just an embedding index. That distinction matters more than it sounds. Embedding-based search finds code that's semantically similar to a query. Sourcegraph's graph knows that UserService.authenticate() is called by twenty-three functions across eight files, three of which are in different repositories. When Amp is planning a change to authenticate(), it has access to that precise dependency map, not a ranked list of probably-relevant snippets.

For a codebase where files reference each other across service boundaries, across language boundaries in a polyglot setup, or across repository boundaries in a multi-repo architecture, that's the thing that separates "the AI made a plausible edit" from "the AI made a correct edit." Plausible and correct diverge faster at scale than most people expect before they've experienced it.

Autonomous task execution with planning

Amp's task execution follows a plan-and-approve model. You describe the task in natural language, Amp builds a plan showing which files it intends to touch and what it intends to do to each, you review and approve or adjust the plan, and then Amp executes. The execution loop includes terminal command support: it can run tests, read the output, and adjust its changes based on failures before presenting you with the final diff.

This is the right model for production code. The plan step is where you catch "it understood the task but misread the data flow." The test loop is where it catches its own logic errors without you having to. The net result on well-scoped tasks is a high rate of "approve this, it's correct" rather than "partially right, let me fix the rest."

The tasks where it does well: renaming a type and updating every reference including across repositories, adding a field to a data model and tracing the propagation through all the serializers and API contracts that touch it, writing integration tests for a module based on its actual usage patterns in the codebase. These are tasks where knowing the true dependency graph matters.

Model flexibility

Amp doesn't push you toward one provider. Claude Sonnet 4.6 and Opus 4.7 are both available, as are GPT-4o and Gemini models. You configure which model handles which context: a fast model for code search and indexing tasks, a frontier reasoning model for complex planning. This matters because the cost of running Opus on every single interaction in a large codebase adds up fast; being able to route intelligently keeps the economics from getting painful.

The model-agnostic approach is also a hedge. If Anthropic's API has an outage, or if a newer model from a different provider becomes meaningfully better at a specific task type, Amp can adapt without requiring a workflow overhaul.

IDE integration

Amp works inside VS Code and JetBrains IDEs as a plugin. The experience is similar to Cursor's Composer mode in that you interact through a side panel, describe tasks, review diffs inline, and accept or reject changes. The difference is that the suggestions have more context depth backing them up.

For teams already using JetBrains IDEs (IntelliJ, PyCharm, GoLand, etc.), this is a meaningful advantage over Cursor, which is VS Code-only. The JetBrains plugin puts Amp in environments that most pure VS Code forks can't reach.

Enterprise codebase support

Sourcegraph has clients with codebases larger than any startup developer has experienced. Amp inherits the infrastructure built for those environments: cross-repository indexing, support for multi-VCS setups (Git, Perforce, SVN), and access controls that let enterprises limit which code the agent can see. These are enterprise requirements that most agentic tools simply haven't been built to handle, because their target user is a developer on a startup project, not a platform engineer at a 10,000-person engineering org.

Pricing

Amp has a free individual tier. The exact feature set on the free tier has evolved since the May 2025 launch, so check ampcode.com for current details.

Enterprise pricing is custom and requires a conversation with Sourcegraph's sales team. That's frustrating if you want a number to put in a budget request, but it's consistent with how Sourcegraph has always sold its code intelligence platform: the price depends on the number of users, the size of the codebase, and the specific configuration.

There's no published mid-market tier with a flat rate, which means Amp is harder to evaluate for teams of ten to fifty engineers who want to move fast without a procurement process. This is a real gap in the product-led-growth story.

Who Amp is built for

The most natural fit is a team that's already using Sourcegraph for code search and navigation. Adding Amp is extending a tool they already trust with infrastructure they've already vetted. The value proposition is immediate and doesn't require a separate security review of a new vendor.

The second strong fit is a platform or infrastructure engineering team managing code across many services or repositories. Augment also targets this space, and it's worth comparing the two. Both are making the bet that codebase context depth is the thing that matters at enterprise scale. Amp's differentiation is the decade of production-proven code intelligence infrastructure behind it.

Individual developers doing typical project work are not the target. For that use case, Cursor, Claude Code, or even Cody will be more practical and better documented.

Amp vs Cody

They're from the same company but they're different products for different tasks. If you're an individual developer or a small team that wants AI completions and chat inside VS Code or JetBrains, Cody is the more appropriate starting point. It's more mature, better documented, and has a clearer path from free to paid.

If you're running large autonomous tasks that require cross-repository context, Amp is the product. You might end up using both: Cody for the daily editing assistance and Amp for the bigger jobs.

Amp vs Claude Code

Claude Code is the stronger comparison for the autonomous task execution angle. Claude Code runs in the terminal, has excellent multi-file reasoning, and supports MCP for external tool connections. It costs $17 a month on the Pro plan.

The difference is context source. Claude Code builds context from reading your files and remembering what it learns across sessions. Amp builds context from Sourcegraph's code graph, which is more precise for cross-file and cross-repo relationships at enterprise scale.

For a developer on a medium-sized project, Claude Code is likely sufficient and the workflow is more mature. For a team with a massive multi-repo codebase, Amp's context quality may justify the switch.

Amp vs Augment

Augment is the closest direct competitor. Both target enterprise teams with large codebases and both differentiate on context quality. Augment is also built on a code indexing approach, though from a different technical foundation.

Amp's advantage is the proven scale of Sourcegraph's existing infrastructure. Augment's advantage is a more polished individual developer experience and more documentation. If you're enterprise-first, evaluate both and run a proof of concept on your actual codebase before committing.

Getting started

Go to ampcode.com and create an account. Connect your IDE through the VS Code or JetBrains extension. Point Amp at your codebase by connecting your repository (GitHub, GitLab, Bitbucket, or self-hosted Sourcegraph are all supported). Let the index build.

Once indexed, start with a clearly scoped task in Builder mode. Something like "add an optional description field to the Product model and propagate it through the API, serializer, and tests" gives Amp a concrete task with a clear success criterion. Review the plan before approving, run the tests after execution, and you'll have a useful data point on whether the context quality lives up to the pitch for your specific codebase.

For enterprise evaluation, Sourcegraph has a sales team that will set up a proof of concept. That's probably the right path for a team above twenty engineers, since the value scales with codebase size and the configuration options matter at that scale.

The bottom line

Sourcegraph Amp is a credible autonomous coding agent for teams where context quality at scale is the real problem. The code intelligence foundation is a genuine differentiator, not just marketing. The enterprise positioning is appropriate given what the infrastructure can actually do at scale.

It's not the right tool for most individual developers or small teams. The maturity gap with Cursor, the opaque enterprise pricing, and the thinner community documentation all push smaller teams toward tools with more established ecosystems.

But if you've hit the context wall with other AI coding tools on a large, complex codebase, Amp is the most technically grounded answer to that specific problem in the current market.

Key features

• Deep codebase context powered by Sourcegraph's code intelligence
• Autonomous multi-step task execution with plan-and-approve flow
• Supports Claude, GPT-4o, and Gemini models
• VS Code and JetBrains IDE integration
• Cross-repository awareness for monorepos and multi-repo setups
• Built-in code search integration for large enterprise codebases
• Agentic loops with terminal command execution

Pros and cons

Who is Sourcegraph Amp for?

• Enterprise teams with large monorepos where AI tools lose context
• Engineering orgs already using Sourcegraph for code search
• Platform teams managing multi-repository architectures
• Senior engineers running large-scale refactors across service boundaries

Alternatives to Sourcegraph Amp

If Sourcegraph Amp isn't quite the right fit, the closest alternatives are cody , claude-code , cursor , and augment . See our full Sourcegraph Amp alternatives page for side-by-side comparisons.