DeepClaude – Claude Code agent loop with DeepSeek V4 Pro, 17x cheaper

Notifications You must be signed in to change notification settings
Fork 13
Star 209

Code
Issues 2
Pull requests 0
Actions
Projects
Security and quality 0
Insights

Additional navigation options mainBranchesTagsGo to fileCodeOpen more actions menu

Folders and files

Name	Name	Last commit message	Last commit date
Latest commit History 13 Commits13 Commits
proxy	proxy
screenshots	screenshots
LICENSE	LICENSE
README.md	README.md
deepclaude.ps1	deepclaude.ps1
deepclaude.sh	deepclaude.sh
View all files

Repository files navigation

README
MIT license

Use Claude Code's autonomous agent loop with DeepSeek V4 Pro, OpenRouter, or any Anthropic-compatible backend. Same UX, 17x cheaper.

Remote control running DeepSeek V4 Pro in the browser

Claude Code is the best autonomous coding agent — but it costs $200/month with usage caps. DeepSeek V4 Pro scores 96.4% on LiveCodeBench and costs $0.87/M output tokens.

deepclaude swaps the brain while keeping the body:

Your terminal
  +-- Claude Code CLI (tool loop, file editing, bash, git - unchanged)
        +-- API calls -> DeepSeek V4 Pro ($0.87/M) instead of Anthropic ($15/M)

Everything works: file reading, editing, bash execution, subagent spawning, autonomous multi-step coding loops. The only difference is which model thinks.

Windows (PowerShell):

setx DEEPSEEK_API_KEY "sk-your-key-here"

macOS/Linux:

echo 'export DEEPSEEK_API_KEY="sk-your-key-here"' >> ~/.bashrc
source ~/.bashrc

Windows:

# Copy the script to a directory in your PATH
Copy-Item deepclaude.ps1 "$env:USERPROFILE\.local\bin\deepclaude.ps1"

# Or add the repo directory to PATH
setx PATH "$env:PATH;C:\path\to\deepclaude"

macOS/Linux:

chmod +x deepclaude.sh
sudo ln -s "$(pwd)/deepclaude.sh" /usr/local/bin/deepclaude

deepclaude                  # Launch Claude Code with DeepSeek V4 Pro
deepclaude --status         # Show available backends and keys
deepclaude --backend or     # Use OpenRouter (cheapest, $0.44/M input)
deepclaude --backend fw     # Use Fireworks AI (fastest, US servers)
deepclaude --backend anthropic  # Normal Claude Code (when you need Opus)
deepclaude --cost           # Show pricing comparison
deepclaude --benchmark      # Latency test across all providers
deepclaude --switch ds      # Switch backend mid-session (no restart)

Claude Code reads these environment variables to determine where to send API calls:

Variable	What it does
`ANTHROPIC_BASE_URL`	API endpoint (default: api.anthropic.com)
`ANTHROPIC_AUTH_TOKEN`	API key for the backend
`ANTHROPIC_DEFAULT_OPUS_MODEL`	Model name for Opus-tier tasks
`ANTHROPIC_DEFAULT_SONNET_MODEL`	Model name for Sonnet-tier tasks
`ANTHROPIC_DEFAULT_HAIKU_MODEL`	Model name for Haiku-tier (subagents)
`CLAUDE_CODE_SUBAGENT_MODEL`	Model for spawned subagents

deepclaude sets these per-session (not permanently), launches Claude Code, then restores your original settings on exit.

Backend	Flag	Input/M	Output/M	Servers	Notes
DeepSeek (default)	`--backend ds`	$0.44	$0.87	China	Auto context caching (120x cheaper on repeat turns)
OpenRouter	`--backend or`	$0.44	$0.87	US	Cheapest, lowest latency from US/EU
Fireworks AI	`--backend fw`	$1.74	$3.48	US	Fastest inference
Anthropic	`--backend anthropic`	$3.00	$15.00	US	Original Claude Opus (for hard problems)

DeepSeek (default - just needs DEEPSEEK_API_KEY):

setx DEEPSEEK_API_KEY "sk-..."           # Windows
export DEEPSEEK_API_KEY="sk-..."         # macOS/Linux

OpenRouter (optional):

setx OPENROUTER_API_KEY "sk-or-..."      # Windows
export OPENROUTER_API_KEY="sk-or-..."    # macOS/Linux

Fireworks AI (optional):

setx FIREWORKS_API_KEY "fw_..."          # Windows
export FIREWORKS_API_KEY="fw_..."        # macOS/Linux

Usage level	Anthropic Max	deepclaude (DeepSeek)	Savings
Light (10 days/mo)	$200/mo (capped)	~$20/mo	90%
Heavy (25 days/mo)	$200/mo (capped)	~$50/mo	75%
With auto loops	$200/mo (capped)	~$80/mo	60%

DeepSeek's automatic context caching makes agent loops extremely cheap - after the first request, the system prompt and file context are cached at $0.004/M (vs $0.44/M uncached).

File reading, writing, editing (Read/Write/Edit tools)
Bash/PowerShell execution
Glob and Grep search
Multi-step autonomous tool loops
Subagent spawning
Git operations
Project initialization (/init)
Thinking mode (enabled by default)

Feature	Reason
Image/vision input	DeepSeek's Anthropic endpoint doesn't support images
Parallel tool use	Supported by DeepSeek (up to 128 per call), but Claude Code sends tools sequentially by default
MCP server tools	Not supported through compatibility layer
Prompt caching savings	DeepSeek has its own caching (automatic), but Anthropic's `cache_control` is ignored

Routine tasks (80% of work): DeepSeek V4 Pro is comparable to Claude Opus
Complex reasoning (20%): Claude Opus is stronger - switch with --backend anthropic

Switch between Anthropic and DeepSeek mid-session - from inside Claude Code itself. No restart, no terminal commands. Just type a slash command.

In Claude Code terminal:

/deepseek in Claude Code CLI

In Claude Code VS Code extension:

/deepseek in VS Code extension

The proxy runs on localhost:3200 and intercepts all API calls. A control endpoint (/_proxy/mode) lets you switch the active backend instantly:

Claude Code -> localhost:3200 (proxy)
                 |
                 +-- /_proxy/mode POST -> switch backend
                 +-- /_proxy/status GET -> current backend + uptime
                 +-- /_proxy/cost GET -> token usage + cost savings
                 |
                 +-- /v1/messages -> active backend (DeepSeek/OpenRouter/Anthropic)
                 +-- everything else -> Anthropic (passthrough)

Add these files to ~/.claude/commands/:

deepseek.md:

Switch the model proxy to DeepSeek. Run this command silently and report the result:
curl -sX POST http://127.0.0.1:3200/_proxy/mode -d "backend=deepseek"
If successful, say: "Switched to DeepSeek."

anthropic.md:

Switch the model proxy back to Anthropic. Run this command silently and report the result:
curl -sX POST http://127.0.0.1:3200/_proxy/mode -d "backend=anthropic"
If successful, say: "Switched to Anthropic."

openrouter.md:

Switch the model proxy to OpenRouter. Run this command silently and report the result:
curl -sX POST http://127.0.0.1:3200/_proxy/mode -d "backend=openrouter"
If successful, say: "Switched to OpenRouter."

Then type /deepseek, /anthropic, or /openrouter in any Claude Code session to switch instantly.

deepclaude --switch deepseek    # or: ds, or, fw, anthropic
deepclaude -s anthropic

Add to .vscode/tasks.json:

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "Proxy: Switch to DeepSeek",
      "type": "shell",
      "command": "Invoke-RestMethod -Uri http://127.0.0.1:3200/_proxy/mode -Method Post -Body 'backend=deepseek'",
      "presentation": { "reveal": "always" },
      "problemMatcher": []
    },
    {
      "label": "Proxy: Switch to Anthropic",
      "type": "shell",
      "command": "Invoke-RestMethod -Uri http://127.0.0.1:3200/_proxy/mode -Method Post -Body 'backend=anthropic'",
      "presentation": { "reveal": "always" },
      "problemMatcher": []
    }
  ]
}

Then bind in keybindings.json:

{ "key": "ctrl+alt+d", "command": "workbench.action.tasks.runTask", "args": "Proxy: Switch to DeepSeek" },
{ "key": "ctrl+alt+a", "command": "workbench.action.tasks.runTask", "args": "Proxy: Switch to Anthropic" }

The proxy tracks token usage and calculates savings vs Anthropic pricing:

curl -s http://127.0.0.1:3200/_proxy/cost

Returns:

{
  "backends": {
    "deepseek": {
      "input_tokens": 125000,
      "output_tokens": 45000,
      "requests": 12,
      "cost": 0.0941,
      "anthropic_equivalent": 1.05
    }
  },
  "total_cost": 0.0941,
  "anthropic_equivalent": 1.05,
  "savings": 0.9559
}

Add terminal profiles so you can launch deepclaude from the IDE:

Settings > JSON:

{
  "terminal.integrated.profiles.windows": {
    "DeepSeek Agent": {
      "path": "powershell.exe",
      "args": ["-ExecutionPolicy", "Bypass", "-NoExit", "-File", "C:\\path\\to\\deepclaude.ps1"]
    }
  }
}

Or on macOS/Linux:

{
  "terminal.integrated.profiles.linux": {
    "DeepSeek Agent": {
      "path": "/usr/local/bin/deepclaude"
    }
  }
}

Open a Claude Code session in any browser - with DeepSeek as the brain:

deepclaude --remote                # Remote control + DeepSeek
deepclaude --remote -b or          # Remote control + OpenRouter
deepclaude --remote -b anthropic   # Remote control + Anthropic (normal)

This prints a https://claude.ai/code/session_... URL you can open on your phone, tablet, or any browser.

Remote control needs Anthropic's bridge for the WebSocket connection, but model calls can go elsewhere. deepclaude starts a local proxy that splits the traffic:

claude remote-control
  +-- Bridge WebSocket -> wss://bridge.claudeusercontent.com (Anthropic, hardcoded)
  +-- Model API calls  -> http://localhost:3200 (proxy)
                            +-- /v1/messages -> DeepSeek ($0.87/M)
                            +-- everything else -> Anthropic (passthrough)

Must be logged into Claude Code: claude auth login
Must have a claude.ai subscription (the bridge is Anthropic infrastructure)
Node.js 18+ (for the proxy)

The proxy starts automatically and stops when the session ends. See proxy/README.md for technical details.

MIT

About

Use Claude Code's autonomous agent loop with DeepSeek V4 Pro, OpenRouter, or any Anthropic-compatible backend. Same UX, 17x cheaper.

Resources

Readme

License

MIT license

Uh oh!

There was an error while loading. Please reload this page.

Activity

Stars

209 stars

Watchers

0 watching

Forks

13 forks Report repository

Releases

No releases published

Packages 0

Uh oh!

There was an error while loading. Please reload this page.

Contributors

Uh oh!

There was an error while loading. Please reload this page.

Languages

JavaScript 46.8%
PowerShell 27.3%
Shell 25.9%

DeepClaude – Claude Code agent loop with DeepSeek V4 Pro, 17x cheaper

Folders and files

Latest commit

History

Repository files navigation

About

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages