Sourcegraph Amp Free 2026: Ad-Backed Coding Agent Test

Sourcegraph Amp Free is the first coding agent that will write your production code for nothing — and show you ads while it does. Sourcegraph shipped an ad-supported tier for its agentic CLI and VS Code extension, betting that display inventory can subsidize frontier-model inference in a way $19-per-seat subscriptions never did. The timing is not subtle: Disney is reportedly moving off GitHub Copilot to OpenAI’s Codex this week, which tells you enterprise assistant loyalty is measured in quarters, not years. A zero-cost path to a genuinely autonomous coder just arrived — but understand what the ads are buying before you point it at a private monorepo.

What’s actually new with Sourcegraph Amp Free

Amp is Sourcegraph’s agentic coding product — not a tab-completion tool, but a full agent that reads your repository, plans multi-file changes, runs commands, reads the output, and iterates. It ships in two surfaces: a terminal CLI (amp) and a VS Code extension that runs the same agent loop in a side panel. Until now, using it meant paying for tokens or a seat. The free tier removes the payment step and inserts advertising instead.

The mechanics matter more than the headline. Amp Free routes requests through models Sourcegraph subsidizes, and in exchange the client displays sponsored placements in the CLI output and the editor panel. Sourcegraph has been explicit that the free tier is not a trial with a cliff — it is a permanent tier funded by a different revenue line. The paid tier still exists for teams that want the ads gone, priority routing, and contractual guarantees about how their code is handled.

The second, less-discussed change is what free access does to the agent’s economics. Agentic coding burns tokens at a rate that dwarfs autocomplete — a single “refactor this module and fix the failing tests” run can consume hundreds of thousands of tokens across dozens of tool calls. An ad-supported coding agent has to keep that cost below the value of the impressions it serves, so Amp Free users should expect model selection, context window, and concurrency tuned for cost rather than raw capability. That is the real trade, and it is a throughput trade as much as a privacy one.

Why Sourcegraph Amp Free matters

• It removes the last excuse for not trying agentic coding. A team that could not get budget approval for Copilot seats can run a real autonomous coder today. Expect a wave of bottom-up adoption that never touches procurement.
• Ad funding changes the data conversation. Advertising requires targeting signal. Even if Sourcegraph never trains on your code, ad relevance implies something about your session feeds selection — language, framework, error patterns, package names. Read the retention terms as carefully as you would read a data processing agreement.
• Enterprise switching costs are collapsing. Disney’s reported move from Copilot to Codex is the tell. When assistants are CLI-shaped and model-agnostic, migration is a config change, not a replatform. Vendors know it, which is why free tiers are appearing now.
• Free tiers pressure the $19–$39 seat model. If Amp Free is good enough for individual contributors, the paid pitch shifts from “access to AI” to “compliance, SSO, and audit logs” — a fundamentally different and smaller market.
• Throughput becomes the differentiator, not intelligence. Once several vendors reach roughly equivalent model quality, what you notice is queue depth, rate limits, and how many parallel agents you can run. Free tiers ration exactly those.
• It sets a precedent other tools will copy. If ads can fund frontier inference for developers — arguably the highest-value ad audience on the internet — every free agentic tool in 2026 gets a new business model to imitate.

How to use Sourcegraph Amp Free today

1. Install the CLI. Amp ships as an npm package, so any recent Node runtime works:

   npm install -g @sourcegraph/amp
   amp --version

   On Windows, use PowerShell or WSL; on macOS and Linux, avoid sudo npm -g by pointing npm at a user-owned prefix first.

2. Authenticate and select the free tier. The login flow opens a browser and writes a token to your local config:

   amp login

   Verify which tier you landed on before you do anything real. An account with a paid entitlement may default to it:

   amp status

3. Scope the agent before you unleash it. Most people skip this step. Amp reads the working directory it launches in, so launch it from the narrowest useful subtree — not the root of a monorepo containing secrets and customer data:

   cd services/billing-api
   amp

4. Add an agent instructions file. Amp reads a project-level guidance file, which keeps it from inventing its own conventions. Create AGENT.md at the repo root:

   # AGENT.md
   
   ## Commands
   - Test: `pnpm test --filter billing-api`
   - Lint: `pnpm lint --fix`
   - Typecheck: `pnpm tsc --noEmit`
   
   ## Rules
   - TypeScript strict mode. No `any`.
   - Never edit files under `db/migrations/` — propose SQL instead.
   - Never read or echo `.env*` files.
   - Tests are colocated as `*.test.ts`.

5. Exclude sensitive paths explicitly. Do not rely on .gitignore alone to keep an agent out of a directory. Configure ignores in your Amp settings file (~/.config/amp/settings.json, or VS Code settings for the extension):

   {
     "amp.ignorePaths": [
       "**/.env*",
       "**/secrets/**",
       "**/*.pem",
       "**/customer-data/**",
       "infra/terraform/state/**"
     ],
     "amp.commands.allowlist": ["pnpm test", "pnpm lint", "git diff", "git status"]
   }

   The command allowlist matters as much as the path ignores. An agent that can run arbitrary shell commands can exfiltrate anything it can read.

6. Give it a task with a verification loop. Agentic tools perform dramatically better when the prompt tells them how to check their own work. Paste something shaped like this:

   Add idempotency-key support to the POST /v1/charges handler.
   
   Requirements:
   - Accept an `Idempotency-Key` header; 400 if longer than 255 chars.
   - Store key + response hash in the existing `request_log` table via
     the repository layer. Do not write raw SQL in the handler.
   - Replaying a key within 24h returns the cached response and sets
     `X-Idempotent-Replay: true`.
   
   Then: run `pnpm tsc --noEmit` and `pnpm test --filter billing-api`.
   Fix anything that fails and re-run until both pass. Show me the diff
   before you touch more than five files.

7. Run it non-interactively in CI or a script. The CLI accepts piped input, which makes it useful for batch work like migrations or codemods:

   echo "Convert all class components in src/legacy/ to function components with hooks. Run pnpm test after each file." | amp
   
   # or fan out over a file list
   git ls-files 'src/legacy/*.jsx' | while read f; do
     echo "Migrate $f to a function component. Preserve prop types. Run the colocated test." | amp
   done

8. Review every diff as untrusted input. Use git as the safety net, not the agent’s self-report:

   git add -A -n
   git diff --stat
   git diff -- ':!*.lock' ':!dist/*'

   Commit on a branch, always. An agent that ran twenty tool calls and declared success has produced a hypothesis, nothing more.

How it compares: Amp Free vs GitHub Copilot and the rest

The free agentic tier is no longer unique — it is table stakes. What differs is where the money comes from and what gets rationed.

Tool	Free tier funding	Agentic depth	Surfaces	Main constraint on free
Sourcegraph Amp Free	Advertising	Full multi-file agent, shell execution, self-verification loop	CLI + VS Code	Ad placements; cost-tuned model routing and throughput
GitHub Copilot Free	Loss-leader for paid seats and Azure	Agent mode available, tightly integrated with PRs and Actions	VS Code, JetBrains, CLI, github.com	Hard monthly caps on completions and chat requests
OpenAI Codex	Bundled into ChatGPT paid plans	Strong cloud-sandboxed agent, parallel task execution	CLI, IDE extension, web	No meaningful free tier; requires a paid plan
Claude Code	Bundled into Claude paid plans	Deep terminal agent, strong long-context refactors	CLI, IDE, desktop, web	No free tier; usage limits by plan
Cursor	Loss-leader for Pro	Agent mode inside a forked editor	Own editor	Limited fast requests; weaker models on free
Google Gemini CLI	Strategic subsidy	Capable agent, generous request allowance	CLI	Rate limits; less mature tooling ecosystem

Read that table as a spectrum of who is paying. Every other free tier here is subsidized by a paid product it is trying to sell you. Amp Free is the only one where a third party pays and you are the audience. That is not automatically worse — plenty of infrastructure runs on ads — but it is a structurally different incentive, and it deserves a different threat model.

What’s next

Watch first whether the unit economics hold. Developer ad inventory is valuable, but agentic sessions are expensive and the ratio is not obviously favorable at frontier-model prices. If it does not pencil out, the likely adjustments are quieter model downgrades, tighter rate limits, or a shift from display ads to sponsored tool integrations — “deploy this with Vendor X” surfacing inside the agent’s suggestions. That last form is far more consequential than a banner, because it puts commercial pressure inside your architecture decisions. Watch for disclosure norms around it.

Second comes regulatory and contractual friction. Ad-supported coding agent tiers sit awkwardly with enterprise procurement, and any organization under SOC 2, HIPAA, or GDPR obligations will need clear answers about retention and sub-processors before Amp Free gets near a private repo. Expect security teams to block it by default, and expect Sourcegraph to respond with an explicit “no ads, no retention” enterprise SKU — which is the actual business model. The free tier is a distribution channel.

Third, watch the churn. The Disney-to-Codex move is a data point in a broader pattern: switching coding assistants enterprise-wide is now a manageable project rather than a multi-year commitment, because the interface has standardized on “agent in a terminal with a config file.” That commoditization is what makes free agentic coding tools 2026’s defining category, and it means the winners will be decided by throughput, trust, and integration depth rather than by who has the smartest model this quarter.

Frequently Asked Questions

Is Sourcegraph Amp Free actually free, or is it a limited trial?

Sourcegraph positions it as a permanent tier funded by advertising rather than a time-boxed trial. But “free” does not mean unmetered — expect rate limits and cost-optimized model routing. Treat throughput, not price, as the thing you trade away.

Does Amp train on my code?

Sourcegraph’s paid tiers have historically committed to not training on customer code, but verify the specific terms attached to the free tier rather than assuming they match. Ad-supported products need targeting signal, so answer these in writing: what session metadata is retained, for how long, which sub-processors see it, and whether any of it informs ad selection. If you cannot get those answers, do not run it on proprietary code.

Where do the ads appear, and can I block them?

Placements surface in the CLI output stream and in the VS Code panel. Blocking them technically would violate the terms that make the tier free, and it is the wrong fight — the paid tier removes them. Consider the price of the paid tier the actual cost of Amp Free.

How does Amp Free vs GitHub Copilot shake out for a small team?

Copilot Free wins if your workflow lives inside GitHub PRs and Actions and you mostly want completions plus occasional agent runs. Amp Free wins if you want deep terminal-driven, multi-file autonomous work and you are hitting Copilot’s monthly request caps. Many teams will run both — they cost nothing and they fail in different ways.

Can I use Amp Free in CI or on a server?

The CLI accepts piped input, so technically yes. Whether you should is a separate question: a non-interactive agent with shell access and no human reviewing diffs is a significant supply-chain risk. If you do it, run it in an ephemeral container, scope the token, use a strict command allowlist, and require human review on every resulting pull request.

What is the single biggest mistake teams make when adopting a free agentic coder?

Launching it from the repository root with no ignore rules and no command allowlist, then approving diffs they did not read. The agent is not the risk — unscoped filesystem access plus unreviewed commits is. Set up AGENT.md, path ignores, and a branch-only workflow on day one, before the first real task.