Free Repo Agent — Free DeepSeek AI Coding Agent · Copilot, Cursor & Claude Code Alternative for VS Code

A free DeepSeek AI coding agent for VS Code — a no-subscription GitHub Copilot, Cursor & Claude Code alternative. Repository-aware chat, autonomous multi-file editing, terminal command running, a terminal CLI, and pre-commit code review, powered by DeepSeek V4.1 Flash & V4 Pro.

🧩 Using Cursor, Windsurf or VSCodium? Install it from Open VSX — search “Free Repo Agent” in your Extensions view.

Free Repo Agent is a free, open AI coding assistant that brings a Claude/Cursor/Cline-style agent experience into VS Code. It understands your whole repository, writes and edits code with inline Keep / Undo review, runs terminal commands with your approval, auto-verifies its own work (runs your typecheck/build and fixes errors before finishing), tracks progress on a live Claude-style task checklist, extends itself with plugins (MCP) — GitHub, web search, Postgres, filesystem and more — shows its thinking, supports @ file mentions, vision (paste a screenshot/UI → build the component), image OCR and PDF uploads, keeps chat history/sessions, and runs a staff-engineer-grade pre-commit code review of your staged git changes — all on the affordable DeepSeek API.

Looking for a free Copilot alternative, a free Cursor alternative, a Claude Code alternative, a Cline / Roo Code / Kilo Code / Continue alternative, or simply the best DeepSeek extension for VS Code? This is a lightweight, bring-your-own-key option with no subscription.

📖 Full docs, all features & bug reports on GitHub → github.com/sumitsingh4411/repo-agent

🚀 Getting started

1. Get a DeepSeek API key

Repo Agent needs a DeepSeek API key to talk to the model.

1. Go to https://platform.deepseek.com/api_keys
2. Sign in (or create a free account).
3. Click Create new API key, give it a name, and copy the key (starts with sk-…). You won’t be able to see it again, so save it somewhere safe.
4. DeepSeek is pay-as-you-go and very low cost — add a small amount of credit under Billing on the same dashboard. A few dollars goes a long way.

💡 Models: deepseek-flash (DeepSeek V4.1 Flash — the default: fast, 1M context, reads images, thinking mode) and deepseek-v4-pro (most capable, text only). Switch from the 🧠 chip in the chat footer or in settings.

2. Add your key to VS Code

Open the Command Palette (Cmd/Ctrl+Shift+P) and run:

Agent: Set DeepSeek API Key

Paste your key and press Enter. It’s stored securely in VS Code SecretStorage — never written to your code or settings.

Alternative: set the DEEPSEEK_API_KEY environment variable before launching VS Code.

3. Start using it

Open the chat any of these ways:

• Click the Repo Agent </> icon in the top-right of the editor toolbar (when a file is open) — this opens chat beside your code, on the right, like Cursor/Claude.
• Press Cmd/Ctrl+Shift+A.
• Click the Repo Agent icon in the Activity Bar (left sidebar).

The status bar shows when indexing is done and the key is set.

💡 Prefer it docked on the right? Show the Secondary Side Bar (Cmd/Ctrl+Alt+B), then drag the Repo Agent icon from the left Activity Bar into the right side bar. VS Code remembers the position.

✨ Features

🧑‍💻 How to use

Chat & generate

Type a question and Send. Toggle Generate code to produce files (you’ll get an Apply button with a diff preview before anything is written). Keep Think on to see the model reason through the answer.

• @ to reference files: type @ and pick a file from the dropdown — its contents are added to the context.
• 📎 to attach: click the paperclip to attach text files or PDFs.

Agent mode (autonomous)

Check Agent (run & edit) and describe a task, e.g.:

“Add a /health route and a test for it, then run the tests.”

The agent will:

1. Read relevant files, then propose edits — each shows inline in the file with green highlights and ✓ Keep / ✗ Undo buttons.
2. Ask to Run any terminal command (inline, in the chat) — commands run in a visible Repo Agent terminal.
3. When done, you get Keep all / Undo all to accept or revert the whole batch.

Use the Stop button anytime to interrupt.

Plan first. Click the 📋 Plan chip (or type /plan) before a big change: the agent only reads and investigates, then replies with what it found, a numbered plan naming every file, and open questions. Click ▶ Execute plan to carry it out, or keep refining.

Rewind. Hover any message you sent and click ↺ Restore to undo every file the agent changed since then (files it created are deleted) and rewind the chat to that point — your message comes back to the input so you can edit and resend. Changes made by shell commands (installs, generated files) aren't undone.

Several chats at once. ⧉ Tab opens another independent chat; each has its own history and its own terminal.

Long chats keep their memory. Older messages are summarized automatically instead of being forgotten; type /compact to do it now.

In your editor

• 💡 Quick Fix: put the cursor on a red/yellow squiggle → lightbulb → ✨ Fix with Repo Agent (or Explain).
• Right-click any code → Repo Agent → Explain · Find & fix bugs · Refactor · Write tests · Add docs (selection, or the whole file).
• ✨ Commit message: click the sparkle in the Source Control title bar.
• ✍️ Autocomplete: grey suggestions appear as you pause typing; Tab accepts. It's on by default — each pause is a small DeepSeek API call, so click Autocomplete in the status bar (or Options → Inline autocomplete) to turn it off.

@-mentions & custom commands

• @path/to/file — the file's contents · @problems — the Problems panel · @diff — your uncommitted changes · @terminal — the active terminal's output · @https://… — a web page.
• Custom slash commands: save a prompt as .repo-agent/commands/review-pr.md (commit it to share with your team) or ~/.repo-agent/commands/ (just for you), then type /review-pr focus on auth. $ARGUMENTS in the file is replaced by what you type after the command; an optional description: front-matter line shows in the / menu. / → New custom command… creates a starter.

Hooks

Run your own scripts around the agent's tool calls with .repo-agent/hooks.json (project) or ~/.repo-agent/hooks.json (yours):

{
  "preToolUse": [{ "matcher": "write_file|edit_file", "command": "./scripts/guard-migrations.sh" }],
  "postToolUse": [{ "matcher": "edit_file", "command": "npx prettier --check $(jq -r .input.path)" }]
}

Each hook gets the event as JSON on stdin (event, tool, input, and result for post hooks). Exit code 2 blocks a preToolUse call (its stderr is told to the agent) or feeds stderr back after a postToolUse call; other exit codes are ignored. Project hooks only run in a trusted workspace, after you approve that exact file.

Code review

Stage some changes (git add …), then run Agent: Review Staged Changes (also available from the Source Control title bar). Findings appear in the Problems panel, the Review Results sidebar, and inline — each with Fix with AI, Ignore, and Commit Anyway.

You can also review the current file or have it run automatically on save (see settings).

Custom review rules. Want the reviewer to enforce your team's standards? Run Agent: Create Review Guidelines (or click the link in the empty Review Results panel) to scaffold a system-design.md at your repo root. Fill it with your intended system design and concrete rules — naming, error handling, "no console.log", required tests, layering, no secrets, etc. The reviewer reads it before every review and flags any change that breaks a rule, quoting it. Configure the filename with repoAgent.review.guidelinesFile; remove the file to fall back to the default rubric.

Vision — paste an image, build the component (free)

No setup needed. The default model, DeepSeek V4.1 Flash (deepseek-flash), reads images natively — so it uses the DeepSeek key you already set. One model, one key, nothing to configure.

1. With Vision on, paste a screenshot/mockup into the input (or attach with +) and ask for what you want.
2. Prefer a different backend? Run Agent: Choose Vision Provider to switch to Google Gemini's free tier, Ollama / LM Studio (local, no key), OpenRouter, OpenAI, or a custom endpoint. Behind the scenes the model turns the image into a precise implementation spec, then the agent builds the files from it. With Vision off (or no key set), attached images fall back to OCR — great for screenshots of code or error messages, and needs no key at all.

Project conventions

Drop an AGENTS.md (the shared standard Codex, Cursor and Claude Code read), .claude.md or .agent.md in your repo root with conventions, architecture notes, or rules — Repo Agent reads it and follows it. For code review specifically, add a system-design.md with rules the reviewer must enforce (see Custom review rules above).

⚙️ Commands

Open the Command Palette and type “Agent:” to see all of them:

⌨️ Terminal CLI (run the agent in your shell)

Prefer working in the terminal, like Claude Code? The same agent ships as a CLI, repo-agent — the full autonomous agent in your shell, no VS Code needed. It plans a live checklist, reads/edits files, and runs commands in your current directory, asking before anything that changes them.

# Auth: set your DeepSeek key once (or paste it when prompted the first time)
export DEEPSEEK_API_KEY=sk-...

repo-agent                          # interactive session
repo-agent "add a /health route"    # seed the first task, then continue

Options: -m, --model <id> · -e, --effort low|medium|high|max · -C, --cwd <dir> · --base-url <url> (any OpenAI-compatible provider) · -y, --yes (auto-approve — use with care) · --login (re-enter your API key) · --plan (investigate & plan first) · -i, --image <file> (screenshot → code) · -c, --continue / -r, --resume (pick up an earlier session) · --no-verify (skip the auto typecheck after edits).

In-session commands: /plan · /image <file> · /resume · /mcp · /login · /model <id> · /effort <lvl> · /clear · /cwd · /help · /exit.

Plugins (MCP) in the terminal: add servers under "mcpServers" in ~/.repo-agent.json, or in a project .mcp.json — the same format Claude Code and Cursor use, so existing setups just work. You approve a project's servers once, and each plugin call is confirmed. Approve each edit/command with y / n / always; press Ctrl-C to stop a run, again to quit.

Your key comes from DEEPSEEK_API_KEY, or is read from ~/.repo-agent.json (saved with chmod 600 only if you opt in). It never leaves your machine except in requests to the model endpoint you configure.

Entered the wrong key? Run repo-agent --login, or type /login mid-session, to replace it. (If you exported a bad DEEPSEEK_API_KEY, unset it too — the env var wins over the saved file.)

The CLI keeps its own key store: the VS Code extension's key lives in VS Code SecretStorage, which a program outside VS Code cannot read.

🔧 Settings

All under repoAgent.* (Settings → search “Repo Agent”):

🔒 Privacy & security

• Your keys stay secret. The DeepSeek key, vision key, and any plugin/remote‑MCP tokens live in VS Code SecretStorage — never in your code, settings, or the extension's storage. Nothing is ever logged.

• No telemetry. The extension makes no analytics or tracking calls. The only network requests go to endpoints you configure — your AI provider (deepseek.baseUrl), your vision provider, and any MCP servers you add. Your code/context is sent to your AI provider only when you make a request (chat, generate, review, run the agent), and nowhere else.

• The agent stays inside your project. File edits are blocked from absolute paths and .. traversal (can't write outside the workspace), commands run in a visible terminal with your approval, and edits show inline with Keep / Undo.

• Plugins run third‑party code. Installing an MCP server (npm/GitHub/remote) executes code you don't control — add only servers you trust. Plugin tools ask before running by default (repoAgent.plugins.autoRun is off); turn it on only for trusted plugins.

• Keep generated files out of git if they're sensitive. memory.md and .repo-agent/knowledge.md (your notes / an auto‑generated project brief) are injected into prompts and committed by default. Add them to .gitignore if they contain anything private:

  .agent-cache/
  .repo-agent/
  memory.md
  

• Review the DeepSeek privacy policy for how the API handles data.

❓ Troubleshooting

• “Set your DeepSeek API key first.” Run Agent: Set DeepSeek API Key (see step 3).
• 401 Unauthorized Your key is wrong/revoked, or you’re out of credit — check https://platform.deepseek.com/api_keys and Billing.
• Agent says a command’s output “could not be captured.” That’s VS Code shell integration not being active — the command still ran in the terminal. It’s on by default for zsh/bash/pwsh in recent VS Code.
• No reasoning shown. “Thinking” requires deepseek-reasoner; it doesn’t apply to autonomous Agent mode (which uses tools).

🆚 A free alternative to GitHub Copilot, Cursor & Claude Code

Free Repo Agent gives you the agentic coding workflow people love in GitHub Copilot Chat, Cursor, Cline, Codex, and Claude — autonomous multi-file edits, terminal commands, codebase-aware answers, a live task checklist, self-verifying edits, MCP plugins, and inline diff review — without a monthly subscription. You bring your own DeepSeek API key (pay-as-you-go, typically a few cents of usage), and everything runs inside VS Code. It’s ideal if you want a free AI pair programmer, a free Copilot alternative, or a cheaper Cursor / Claude alternative for everyday coding and code review. If you’ve looked at Cline, Roo Code, Kilo Code, Continue, Claude Code, Codeium, Windsurf, Tabnine, Cody, or Aider and want a simple, bring-your-own-key agent that edits code, self-verifies, and reviews diffs inside VS Code, Free Repo Agent is a lightweight alternative to all of them.

❓ FAQ

Is Free Repo Agent really free? Yes — the extension is free and open. You only pay DeepSeek’s low pay-as-you-go API usage (you bring your own key).

Is it a good GitHub Copilot / Cursor / Claude alternative? Yes. You get repo-aware chat, an autonomous coding agent that edits files and runs commands, visible reasoning, and pre-commit code review — the same core workflow, with no subscription.

Is it a free Cline / Roo Code / Kilo Code / Continue alternative? Yes. Like Cline, Roo Code, Kilo Code and Continue, it's an in-editor agent that reads your repo, edits multiple files, and runs commands — bring-your-own-key with DeepSeek, so there's no subscription. It adds a live task checklist, auto-verify/self-fix, and a staff-engineer code reviewer on top.

Is there a free Claude Code alternative that runs in the terminal? Yes — Repo Agent ships a terminal CLI (repo-agent) alongside the VS Code extension. It's the same autonomous agent in your shell: it plans a live checklist, reads and edits files, and runs commands, asking before each change. See Terminal CLI above. That also makes it a lightweight Aider alternative.

Is there a free DeepSeek extension / DeepSeek agent for VS Code? Yes — this is one. Free Repo Agent is built for DeepSeek: it's a full DeepSeek coding agent (not just chat) that edits files, runs commands, reads screenshots, and reviews code, using your own DeepSeek API key.

How do I use DeepSeek V4.1 Flash in VS Code? Install Free Repo Agent, run Agent: Set DeepSeek API Key, and you're done — DeepSeek V4.1 Flash (deepseek-flash) is the default model. Switch to DeepSeek V4 Pro from the 🧠 chip in the chat footer. Thinking mode is built in and follows the ⚡ Effort dial.

Can I use it in Cursor, Windsurf, or VSCodium? It's published on Open VSX — the extension registry Cursor, Windsurf and VSCodium install from. Search “Free Repo Agent” in their Extensions view.

Does it fix its own mistakes? Yes — after editing it automatically runs your project's typecheck/build, reads the errors, and fixes them before finishing, so you don't get code that fails to compile.

Can I add plugins / MCP servers? Yes. Open the 🧩 Plugins panel in chat and add tools the agent can use — GitHub, web search, Postgres, filesystem, Puppeteer and more — with one click, or add any custom MCP server. Plugins use the Model Context Protocol (the same plugin system Claude uses), so the huge MCP ecosystem works here. (Requires Node/npx on your PATH.)

Do I need an API key? Yes — a DeepSeek API key from https://platform.deepseek.com/api_keys. Set it via Agent: Set DeepSeek API Key. It’s stored securely in VS Code SecretStorage.

Which models does it use? DeepSeek V4.1 Flash (deepseek-flash) by default — fast, 1M context, natively multimodal, with thinking mode — and DeepSeek V4 Pro (deepseek-v4-pro) for the hardest work. You can also point it at any OpenAI-compatible provider to use GPT, Claude or others.

Can it edit my code and run commands automatically? It proposes edits inline with Keep / Undo and asks before running any terminal command — you stay in control.

Does it work like an AI code reviewer? Yes — it reviews your staged git changes and reports Critical / Quality / Architecture / Testing findings, like a senior engineer. You can also give it custom review rules in a system-design.md file and it enforces your project's standards on every review.

Does my code leave my machine? Only the context needed for a request is sent to the DeepSeek API when you ask. Your key never leaves SecretStorage. See Privacy above.

License

MIT — see the bundled LICENSE file.

_{Keywords: free AI coding agent, AI coding assistant, AI agent for VS Code, agentic coding, vibe coding, GitHub Copilot alternative, free Copilot, Copilot Chat alternative, Cursor alternative, Claude alternative, Claude Code alternative, Codex alternative, OpenAI Codex alternative, Cline alternative, Continue alternative, Codeium alternative, Windsurf alternative, Tabnine alternative, Cody alternative, Aider alternative, Roo Code alternative, Kilo Code alternative, ChatGPT for VS Code, DeepSeek VS Code extension, DeepSeek extension for VS Code, DeepSeek agent, DeepSeek coding agent, DeepSeek V4.1 Flash, DeepSeek Flash, DeepSeek V4 Pro, DeepSeek in Cursor, DeepSeek Coder, Open VSX AI agent, terminal AI coding agent, AI coding CLI, MCP, Model Context Protocol, MCP client for VS Code, MCP plugins, AI code review, AI code reviewer, custom code review rules, project review guidelines, vision AI coding, screenshot to code, image to code, UI to code, AI pair programming, agent mode, autonomous coding agent, self-verifying AI agent, AI refactoring, AI code generation, repo-aware AI assistant, bring your own key AI.}