Amp Code Free Is Paused: What It Was and What to Use Instead

Amp Code is a coding agent from Sourcegraph that runs in your editor and in your terminal. It reads your repo, edits files, runs commands, and iterates until a task is done. For about eight months it also had the most interesting free tier in AI coding — and that’s now paused, which is the part of this story most older guides get wrong.

The short history: Amp Free launched in October 2025, funded by ads and a training-data requirement. A week in, Sourcegraph dropped the training clause because ads alone covered the cost. In March 2026 it dropped the ads too and switched to a daily free-credit grant. By mid-2026 the free tier was paused outright, with Sourcegraph saying it doesn’t intend to bring it back. Frontier tokens got expensive faster than ad revenue could follow.

What’s left is still a very good agent. Amp Smart is usage-priced, no subscription, with frontier models and full context windows, and the CLI (amp -x for scripts and pipes) is one of the better automation surfaces in this category. This guide covers what the free tier was, what replaced it, and how to run the agent without it biting you.

What Amp actually is

Amp is not autocomplete with a chat sidebar. It’s an agent loop: it plans, reads files, runs your build and test commands, edits code, reads the output, and tries again. That difference matters for how you use it. You don’t ask Amp to “write a function”, you give it an outcome and a way to verify that outcome.

Four design choices define it:

What Amp costs you now

Amp has three tiers. The differences that matter are the model mix, your context window, and what happens to your code.

Amp Free (paused)

Amp Smart (paid)

Smart mode is usage-priced. You pay for tokens at model list prices, passed through with no markup for individuals or teams.

Plan comparison

My default now: Smart with a spend cap for anything real. For $0 work, FreeBuff is where the actually-free agent tier went. If your employer has a policy about AI tools and source code (most 2026 policies do), check which mode and which retention terms apply before you point any agent at a work repo.

Prerequisites

You need less than you’d think, but you do need these:

RAM and disk are a non-issue on a normal laptop. On a small VPS, remember that the agent is a Node process and it will run your build, so a 1 GB box is not the place for that.

Install the CLI first, then the editor

Install the CLI first even if you plan to live in the editor. It’s the fastest way to confirm auth works, and it’s the same account.

1. Install

# install script: macOS, Linux, WSL
curl -fsSL https://ampcode.com/install.sh | bash

# Or via npm (needs Node 20+)
npm install -g @sourcegraph/amp

# Or pnpm
pnpm add -g @sourcegraph/amp

# Or yarn
yarn global add @sourcegraph/amp

2. Verify the install

amp --version
amp --help

You should get a version string and a list of flags. Verify the flags you’re about to script against. Amp ships fast, and this is the one place where the docs and your binary can disagree. amp --help on your machine is the source of truth.

If you get command not found: amp:

# npm global installs land in the npm prefix
npm config get prefix

# make sure the bin directory is on your PATH, then reload your shell
echo $PATH | tr ':' '\n' | grep -i npm
exec $SHELL -l

For the install-script path, the binary usually lands in ~/.local/bin. Same fix: add it to your PATH.

3. First run and authenticate

cd ~/src/scratch-repo
git status          # expect a clean tree
amp

On first run Amp prompts you to log in and prints a URL (or opens your browser) to connect the account. After that you land in an interactive thread.

4. Verify the agent actually works

Don’t trust “it installed”. Prove it can read and act:

what files are in this folder?

Then ask for something that touches disk, and check git:

add a README.md with the project name and one line describing it

git diff --stat   # you should see README.md appear
git status

If git status shows the new file, the agent’s file tools work. If it shows nothing, the extension is probably running against a different working directory than you think, so check the folder you launched Amp from.

You can also feed context through a pipe:

echo "summarize what this project does based on the file list" | amp

5. Install the editor extension

1. Sign in at ampcode.com
2. Install the Amp extension from the VS Code Marketplace
3. Open the Amp panel and confirm it’s authenticated (same account as the CLI)
4. Open a repo and start a thread

The same extension works in Cursor and in Devin Desktop (formerly Windsurf), if you’d rather use a purpose-built AI editor than VS Code with an extension bolted on.

JetBrains and Neovim support works through the CLI bridge rather than a native plugin:

# VS Code, Cursor, or Neovim with the Amp extension installed
amp --ide

# JetBrains IDEs
amp --jetbrains

That bridge is what gives the CLI eyes: currently open files, your selection, editor diagnostics, and direct edits with undo support.

Verify the bridge: open the editor’s integrated terminal in the same window and run amp --ide. If the CLI can’t see your open file, you’re in a terminal that isn’t attached to the editor (a separate SSH session, for example).

Put an AGENTS.md in the repo

Amp reads AGENTS.md files to learn how your project is built, tested, and reviewed. It looks in the repo root, in subdirectories you’re working in, and in $HOME/.config/amp/AGENTS.md for personal preferences.

# Project notes for agents

## Commands
- dev: `npm run dev`
- build: `npm run build`
- test: `npm test`
- lint: `npm run lint -- --max-warnings 0`

## Architecture
- Astro frontend, static output in `dist/`
- Content collections in `src/content/`
- No server runtime; anything dynamic is a Cloudflare Worker

## Conventions
- TypeScript strict mode, no `any`
- Run `npm test` before proposing a change as done
- Never edit files in `dist/`: they are generated

Blast radius: permissions, sandboxing, rollback

This is the section most Amp guides skip, and it’s the one that decides whether you had a good week.

Amp asks for approval before it runs commands that change things. Approve each one deliberately. The CLI also lets you skip those prompts entirely, with a flag that is literally named as a warning:

# Do NOT run this in a repo that can deploy, migrate, or reach prod credentials
amp --dangerously-allow-all

The flag exists for sandboxed containers and throwaway VMs. If you use it on your laptop in a repo that has a terraform apply, a migration script, or a deploy target, you’ve given an LLM unattended shell access to your infrastructure.

Rules that keep the agent boring

Rollback when it goes wrong

Agent edits are just file changes, so your recovery path is git:

git diff                    # see everything it touched
git restore src/            # throw away changes in one path
git checkout -- .           # throw away all unstaged changes
git stash                   # park its work and get back to a known state
git reflog                  # find a commit it walked over

If you need a refresher on the plumbing, I keep a git commands reference for exactly these moments.

Inside Amp, the thread’s File Changes view lets you revert individual files or the whole thread, and a new thread is a clean slate. If you’re stuck in a loop where the agent keeps “fixing” the same file, stop it, revert, and start a fresh thread with a tighter prompt. Thrashing threads are a known failure mode, and continuing one only burns more tokens.

Working in the editor

The extension turns conversations into threads, which behave like git branches for agent sessions. Each thread keeps its own context, file changes, and history.

A typical session

You: "Fix the TypeScript errors in this file"

Amp:
- reads the file and the diagnostics
- fixes each error
- runs tsc to verify
- shows the diff

Or something that needs a browser:

You: "Look at localhost:3000 and make the header more minimal"

Amp:
- screenshots the running page
- reads the current header markup and styles
- edits the component
- screenshots again to confirm
- iterates until it looks right

The CLI: slash commands and shell mode

Beyond -x, the CLI has its own command set.

Custom commands are files. A markdown file becomes a prompt template, an executable runs and pipes its output to Amp:

# .agents/commands/pr-review.md becomes /pr-review

# ~/.config/amp/commands/outline becomes /outline
#!/usr/bin/env bash
tree -L 2 "$@"

Shell mode inside the CLI:

.ls -la      # runs the command and adds the output to context
$pwd         # incognito: runs, but the output stays out of context

The . versus $ distinction is worth remembering the first time you cat a .env file by accident.

Running it non-interactively

-x / --execute runs a one-shot task without an interactive session. It needs paid credits, so this is a Smart-mode feature:

amp -x "which files in this folder are markdown?"
# README.md
# AGENTS.md
# docs/getting-started.md

cat package.json | amp -x "which package manager is this?"
# npm

git diff | amp -x "write a one-line commit message for these changes"
# fix: resolve type errors in the auth module

A safer automation pattern is to wrap it in guards rather than calling it from your shell history:

#!/usr/bin/env bash
set -euo pipefail

# Never start from a dirty tree: you lose the ability to separate agent edits
git diff --quiet || { echo "Commit or stash first."; exit 1; }

git switch -c "amp/$(date +%Y%m%d-%H%M)"

amp -x "Run the test suite. Fix only failures caused by type errors. Do not change test expectations."

For CI, keep the scope tiny and cap the cost. A review job on a PR diff is the sweet spot:

name: amp-review
on: [pull_request]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
        with:
          fetch-depth: 0
      - name: Install Amp
        run: curl -fsSL https://ampcode.com/install.sh | bash
      - name: Review the diff
        env:
          AMP_API_KEY: ${{ secrets.AMP_API_KEY }}
        run: |
          git diff origin/${{ github.base_ref }}...HEAD > /tmp/pr.diff
          amp -x "Review /tmp/pr.diff for bugs, injection risks, and missing error handling. Under 200 words." | tee review.md

If you’re running agents on a remote box, do it inside tmux so a dropped SSH session doesn’t kill the thread mid-edit. That’s the same discipline as any other long-running process, which is what tmux basics is for. On macOS, terminal multiplexers built for agents like cmux and Herdr are worth a look once you’re running more than one session.

Advanced features worth knowing

Oracle: a second opinion on hard problems

Oracle routes to a deeper reasoning model when the main loop shouldn’t guess. The agent decides when to call it, but asking explicitly gets better results on gnarly work:

"Use the oracle to review the last commit. I want to confirm the logic is
unchanged and only the implementation moved."

"Analyze how these two functions overlap, then ask the oracle how to remove
the duplication while staying backwards compatible."

Oracle doesn’t exist on Free. It’s a Smart-mode tool, and it’s token-expensive, so reach for it on design decisions, not formatting.

Subagents for parallel work

Amp can spawn subagents with their own context windows. Each one can edit files and run commands, and reports back to the main thread.

"Use 3 subagents to convert these CSS files to Tailwind. One subagent per file."

Also Smart-only. Cap the count: three parallel subagents is usually a good ceiling, and each one multiplies your token spend.

Custom tools with MCP

Amp speaks Model Context Protocol, so you can wire in external tools. Config goes in your settings:

"amp.mcpServers": {
  "playwright": {
    "command": "npx",
    "args": ["-y", "@playwright/mcp@latest", "--headless"]
  },
  "linear": {
    "url": "https://mcp.linear.app/sse"
  }
}

Two things to keep in mind. First, an MCP server is a tool call the agent can make without asking you in detail. A scraper or a browser server holding your cookies is a real capability, not a toy. Second, the agent will happily read whatever the server returns into context, so a web-fetch MCP that pulls a 200 KB page costs you tokens. I’ve written about the practical side of this in the Bright Data MCP guide and the MCP intro.

Amp Tab: experimental completions

Amp Tab anticipates multi-line edits and related changes in other files, using language server diagnostics as signal. It’s off by default:

"amp.tab.enabled": true

Press Tab to accept and jump to the follow-on edits. Treat it as experimental: it’s the part of Amp most likely to change shape between releases.

Prompts that actually work

"Fix the TypeScript errors in this file"

"Run the tests and fix the failures you caused"

"Review this API design and suggest improvements" (uses Oracle)

"Add a dark mode toggle to this React component"

"Plan how to add real-time chat to this app. Don't write code yet."

"Find where authentication is handled and describe the flow"

"git blame this file and tell me who added that function"

"Check git diff --staged and remove the debug statements"

"Look at the last commit and help me move this feature to a shared package"

amp -x 'which files in this folder are markdown?'

git log --oneline -10 | amp -x "summarize the recent changes"

amp -x "Look at localhost:3000 and make the header more minimal"

The pattern behind all of these: give the agent a task and a way to check itself. “Run the tests and fix the failures” beats “make the tests pass” because the first one requires evidence.

Limits and what breaks

Smart mode is a meter, not a wall, so most failures are environmental rather than billing. Know these before you plan your week around either mode.

Amp vs the alternatives

Amp’s selling point used to be that the free tier was genuinely free. With that paused, the pitch is simpler: a good agent, honest metered pricing, and a strong CLI. Its trade-off is unchanged — you can’t choose the model, and you can’t bring your own key.

If Amp’s model routing is a dealbreaker, the practical escape hatches are:

• OpenCode Go: open-source agent with a flat-rate bundle of coding models (see my OpenCode Go plan breakdown for what’s actually included)
• Agent Router: one key in front of Claude Code, Codex, and Gemini CLI, when you want to switch models without switching tools
• Factory Droid CLI: agents that go further up the lifecycle than file edits, closer to planning and CI work

For a wider field, my AI coding tools comparison covers the whole 2026 market, and if you’re still deciding whether agents fit your workflow at all, start with getting started programming with AI.

Where Amp still wins: zero config. No API key to wire up, no model dropdown to get wrong, and the CLI automates well. The free tier was the on-ramp; what’s left is the agent itself, and it’s good enough to justify a metered bill for real work.

Frequently asked questions

Conclusion

Amp Code is a good agent that briefly had the most interesting business model in AI coding. The free tier is paused — ads couldn’t keep up with frontier token prices — and what’s left is a straightforward usage-priced agent with frontier models, Oracle, and subagents, plus a CLI that automates better than most.

Key takeaways:

Install it on a scratch repo tonight, run one real task, and check the diff. That tells you more about whether an agent belongs in your workflow than any comparison table, mine included.