---
title: "OpenCode Setup Guide: Open-Source-Claude-Code-Alternative auf deinem VPS"
description: "Installiere und konfiguriere OpenCode auf einem Linux-VPS. Verbinde es mit günstigen Open-Source-Modellen wie MiniMax M2.7, Qwen 3.6 und DeepSeek V4."
date: 2026-04-30
categories: ["ai"]
tags: ["ai-tools","self-hosted","vps"]
---

*Hinweis: Dieser Guide enthält Referral-Links. Wenn du darüber kaufst, erhalte ich möglicherweise eine Provision – ohne zusätzliche Kosten für dich.*

Claude Code ist großartig. Ich nutze es. Aber es kostet mindestens 20 $/Monat, verbrät deine Rate-Limits schnell, und wenn du im Jahresplan bist, hängst du an Anthropics Preisen fest. Da GitHub Copilot [am 1. Juni auf nutzungsbasierte Abrechnung umstellt](/github-copilot-alternatives-2026/), suchen viele Entwickler nach etwas, das sie selbst kontrollieren können.

[OpenCode](https://opencode.ai/) ist die Open-Source-Alternative, die immer besser wird. Über 120.000 GitHub-Stars, 75+ Modell-Provider – und du kannst es auf einem VPS für 6 $/Monat mit Open-Source-Modellen betreiben, die pro Anfrage nur Centbeträge kosten. Ich nutze es seit ein paar Wochen neben [Hermes Agent](/hermes-agent-setup-guide/) und [OpenClaw](/clawdbot-setup-guide/), und es ist mein Standard-Terminal-Coding-Agent geworden.

Dieser Guide behandelt die Installation auf einem Linux-VPS, die Anbindung günstiger Modelle und den Workflow, den ich tatsächlich im Alltag nutze.

**Was dieser Guide abdeckt**

- OpenCode auf einem Linux-VPS in unter einer Minute installieren

- Günstige Open-Source-Modelle über OpenRouter und direkte Provider anbinden

- OpenCode Go für 10 $/Monat einrichten – mit Zugriff auf 16 Modelle

- Plan-Modus vs. Build-Modus, der /init-Workflow und echte Nutzungstipps

- Wie OpenCode im Vergleich zu Claude Code, Codex CLI und Aider abschneidet

## Was OpenCode eigentlich ist

OpenCode ist ein terminalbasierter KI-Coding-Agent. Er liest deine Codebase, plant Änderungen, bearbeitet Dateien, führt Befehle aus und iteriert über Fehlschläge – dieselbe Schleife, die Claude Code durchläuft, nur Open Source und providerunabhängig. Er funktioniert mit Anthropic, OpenAI, Google, Alibaba, MiniMax, DeepSeek, Xiaomi, Moonshot und über 70 weiteren Providern. Über Ollama kannst du auch lokale Modelle nutzen.

Der entscheidende Unterschied zu Claude Code: Du wählst Modell und Provider selbst. Wenn Claude Sonnet für eine Aufgabe zu teuer ist, wechselst du zu Qwen 3.6 Plus für 0,33 $/M Input-Tokens. Brauchst du maximales Reasoning, wechselst du zu GLM 5.2. Du kontrollierst die Kosten.

[OpenCode auf GitHub](https://github.com/anomalyco/opencode)

## OpenCode auf einem VPS installieren

Das Install-Skript erledigt alles. Auf einem Linux-VPS:

```bash
curl -fsSL https://opencode.ai/install | bash
```

Das installiert die `opencode`-Binary. Prüfe, ob sie funktioniert:

```bash
opencode --version
```

Andere Installationsmethoden, falls das Skript für dein Setup nicht funktioniert:

### npm

```bash
npm install -g opencode-ai
```

### Bun

```bash
bun install -g opencode-ai
```

### Homebrew

```bash
brew install anomalyco/tap/opencode
```

### Docker

```bash
docker run -it --rm ghcr.io/anomalyco/opencode
```

### Was du brauchst

- Node.js 18+ (das Install-Skript kümmert sich auf den meisten Systemen darum)
- Einen API-Key von mindestens einem Provider
- Einen Terminal-Emulator mit Bild-Support, wenn du Screenshots per Drag-and-drop einfügen willst (WezTerm, Ghostty, Kitty oder Alacritty)

Auf einem headless VPS brauchst du den Bild-Support nicht. OpenCode funktioniert problemlos über einfaches SSH.

## Einen Modell-Provider konfigurieren

OpenCode unterstützt drei Wege, Modelle anzubinden – vom einfachsten bis zum flexibelsten.

### Option 1: OpenCode Zen (am einfachsten)

OpenCode Zen ist der eingebaute Provider. Du meldest dich bei [opencode.ai/auth](https://opencode.ai/auth) an, bekommst einen API-Key und fügst ihn in OpenCode ein. Der Zen-Provider hat eine kuratierte Liste von Modellen, die vom OpenCode-Team getestet und verifiziert wurden.

Führe `/connect` in der TUI aus, wähle `opencode` und füge deinen Key ein.

### Option 2: OpenRouter (die meisten Modelle)

OpenRouter gibt dir über einen einzigen API-Key Zugriff auf mehr als 200 Modelle. Das nutze ich für den Großteil meiner Arbeit.

```bash
# Add your OpenRouter key
echo "OPENROUTER_API_KEY=your-key-here" >> ~/.config/opencode/.env
```

Führe dann in OpenCode `/connect` aus und wähle OpenRouter.

### Option 3: Direkte Provider-Keys

Für bestimmte Provider kannst du Umgebungsvariablen direkt setzen:

```bash
# MiniMax
echo "MINIMAX_API_KEY=your-key" >> ~/.config/opencode/.env

# Z.AI (GLM)
echo "ZAI_API_KEY=your-key" >> ~/.config/opencode/.env

# Xiaomi MiMo
echo "MIMO_API_KEY=your-key" >> ~/.config/opencode/.env

# DeepSeek
echo "DEEPSEEK_API_KEY=your-key" >> ~/.config/opencode/.env

# Moonshot (Kimi)
echo "MOONSHOT_API_KEY=your-key" >> ~/.config/opencode/.env
```

## OpenCode Go: 10 $/Monat, alle Modelle inklusive

Wenn du nicht mehrere API-Keys verwalten willst, bündelt das [OpenCode-Go-Abo für 10 $/Monat](/de/opencode-go-plan/) 16 Modelle (Grok 4.5, Kimi K3, GLM-5.2, DeepSeek V4, MiniMax M3 und mehr) in einem einzigen API-Key. Für eine detaillierte Aufschlüsselung der Limits, der Modellqualität und der Praxisnutzung lies das vollständige [OpenCode-Go-Review](/de/opencode-go-plan/).

[OpenCode Go](https://go.bitdoze.com/opencode-go)

### Was du bekommst

- 10 $/Monat
- MiniMax M3, M2.7, MiMo V2.5 Pro, GLM 5.2, Kimi K2.5, K2.6, DeepSeek V4 Pro, V4 Flash, Qwen 3.5 Plus, Qwen 3.6 Plus und mehr
- Modelle gehostet in den USA, der EU und Singapur
- Zero-Retention-Policy

### Nutzungslimits

| Limit | Obergrenze |
|-------|-----|
| Pro 5 Stunden | 12 $ |
| Pro Woche | 30 $ |
| Pro Monat | 60 $ |

Günstigere Modelle reichen weiter. MiniMax M3 gibt dir geschätzt 3.400 Anfragen pro 5 Stunden. GLM 5.2 gibt dir 620.

### Einrichtung

Abonniere auf [opencode.ai/auth](https://go.bitdoze.com/opencode-go), kopiere deinen API-Key, dann in OpenCode:

```
/connect
```

Wähle `OpenCode Go` und füge deinen Key ein. Wechsle Modelle mit `/models`.

Der Go-Endpunkt ist auch per API unter `https://opencode.ai/zen/go/v1/chat/completions` erreichbar – du kannst ihn also auch mit [Hermes Agent](/hermes-agent-setup-guide/) oder [OpenClaw](/clawdbot-setup-guide/) nutzen.

## Mit OpenCode im Alltag arbeiten

### Ein Projekt initialisieren

Wenn du OpenCode zum ersten Mal in einem Projekt öffnest:

```bash
cd /path/to/project
opencode
```

Dann führe aus:

```
/init
```

OpenCode analysiert deine Codebase und legt eine `AGENTS.md`-Datei im Projekt-Root an. Diese Datei beschreibt OpenCode deine Projektstruktur, Coding-Patterns und Konventionen. Du kannst sie manuell bearbeiten, um eigene Anweisungen hinzuzufügen.

### Plan-Modus vs. Build-Modus

Das ist der Workflow, zu dem ich immer wieder zurückkehre. Drücke **Tab**, um zwischen den Modi zu wechseln:

**Plan-Modus** (read-only): OpenCode liest deine Codebase und beschreibt, wie es ein Feature implementieren würde. Es werden keine Änderungen vorgenommen. Du prüfst den Plan, gibst Feedback, iterierst.

**Build-Modus** (read-write): OpenCode nimmt die tatsächlichen Änderungen an deinen Dateien vor.

Das Muster:

1. Wechsle mit Tab in den Plan-Modus
2. Beschreibe, was du willst
3. Prüfe den Plan, ergänze Constraints oder Bilder
4. Wechsle mit Tab in den Build-Modus
5. Sag ihm, er soll loslegen

Das ist sicherer, als den Agent sofort loslaufen zu lassen – besonders bei Produktionscode.

### Dateien referenzieren

Nutze `@`, um OpenCode auf bestimmte Dateien zu verweisen:

```
Look at @src/api/auth.ts and add the same pattern to @src/api/settings.ts
```

### Rückgängig machen und wiederholen

Wenn OpenCode eine Änderung macht, die dir nicht gefällt:

```
/undo
```

Das macht die Änderungen rückgängig und zeigt deinen ursprünglichen Prompt wieder an, damit du ihn umformulieren kannst.

```
/redo
```

Holt die Änderungen zurück, wenn du es dir anders überlegst.

### Konversationen teilen

```
/share
```

Erstellt einen Link zu deiner aktuellen Konversation. Nützlich, um Teamkollegen zu zeigen, was der Agent gemacht hat, oder eine zweite Meinung zum Plan einzuholen.

## Das richtige Modell für die Aufgabe wählen

Nicht jede Aufgabe braucht das teuerste Modell. Das nutze ich:

| Aufgabe | Modell | Warum |
|------|-------|-----|
| Schnelle Edits, Datei-Refactoring | MiniMax M2.7 | Günstig und schnell, bewältigt die meisten Edits problemlos |
| Frontend-Arbeit, UI-Generierung | Qwen 3.6 Plus | Stark bei „Vibe Coding" und Design |
| Komplexe Multi-File-Änderungen | GLM 5.2 | Beste Coding-Genauigkeit, den Preis wert |
| Langer Kontext, große Repos | DeepSeek V4 Pro | 1M Kontext, niedrige Halluzinationsrate |
| Standard für den Alltag | MiniMax M2.7 oder Qwen 3.6 Plus | Ausgewogenes Verhältnis von Kosten und Qualität |

Wechsle Modelle in OpenCode mit `/models`. Kein Neustart nötig.

## OpenCode vs. Claude Code vs. Codex CLI

| Feature | OpenCode | Claude Code | Codex CLI |
|---------|----------|-------------|-----------|
| **Preis** | Kostenlos (API-Nutzung bezahlen) | 20 $/Monat + API | In ChatGPT enthalten |
| **Modellauswahl** | 75+ Provider | Nur Anthropic | Nur OpenAI |
| **Open Source** | Ja | Nein | Ja |
| **Plan-Modus** | Ja (Tab-Taste) | Nein (/plan nutzen) | Nein |
| **Bild-Support** | Drag-and-drop | Bilder einfügen | Nein |
| **MCP-Server** | Ja | Ja | Ja |
| **Undo/Redo** | /undo, /redo | Git-basiert | Nein |
| **VPS-tauglich** | Ja | Ja | Ja |

Der größte Vorteil von OpenCode gegenüber Claude Code ist die Modellauswahl. Du bist nicht an Anthropics Preise gebunden. Wenn Claude Sonnet zu teuer wird, wechselst du für Routineaufgaben zu einem günstigeren Modell und hebst Claude für die harten Fälle auf.

Der größte Vorteil gegenüber Codex CLI ist der Plan-Modus und die Möglichkeit, mit Nicht-OpenAI-Modellen zu arbeiten.

**Abo-Risiko**

Die Nutzung der OAuth-Tokens deines Claude-Code- oder ChatGPT-Abos mit automatisierten Coding-Agents kann zur Sperrung deines Accounts führen. Diese Provider überwachen auf automatisierte Nutzung. Verwende stattdessen API-Keys der oben genannten Modelle. Unser [Modell-Guide](/best-opensource-models-for-openclaw/) hat die vollständige Aufschlüsselung.

## OpenCode persistentes Gedächtnis hinzufügen

OpenCode unterstützt MCP-Server – du kannst ihm also mit [Hindsight](/de/hindsight-docker-deployment/) ein Langzeitgedächtnis geben. Es gibt ein [Community-Plugin](https://hindsight.vectorize.io/integrations), das deine Konversationen automatisch speichert und beim Session-Start relevanten Kontext abruft. Es fügt Retain-, Recall- und Reflect-Tools direkt in OpenCodes Tool-Palette ein.

Wenn du lieber den MCP-Server-Ansatz nutzen willst:

```bash
# After deploying Hindsight (see the guide linked above)
# Add it as an MCP server in your opencode config
```

Das ist nützlich, wenn du über mehrere Sessions hinweg am selben Projekt arbeitest und OpenCode sich an Entscheidungen, Konventionen und vergangene Debugging-Sessions erinnern soll.

## OpenCode auf einem VPS über SSH betreiben

OpenCode funktioniert über SSH. Ich betreibe es auf einem Hetzner-VPS für 6 $/Monat und verbinde mich von meinem Laptop aus. Ein paar Tipps:

Nutze **tmux**, damit deine Session überlebt, wenn die SSH-Verbindung abbricht:

```bash
tmux new -s code
cd /path/to/project
opencode
```

Wenn du die Session detachst (`Ctrl+B, D`) und dich später neu verbindest, bringt dich `tmux attach -t code` genau dorthin zurück, wo du aufgehört hast.

Für ein besseres Terminal-Erlebnis über SSH nutze **mosh** statt plain SSH. Es handhabt Netzwerkabbrüche und Roaming besser:

```bash
mosh user@your-vps-ip
```

## FAQ

**Ist OpenCode wirklich kostenlos?**

Die Software ist kostenlos und Open Source. Du zahlst für die LLM-API-Nutzung. Bei OpenCode Go sind das 5 $ im ersten Monat, danach 10 $/Monat. Bei direkten Provider-Keys zahlst du pro Token. MiniMax M2.7 über OpenRouter kostet 0,30 $/M Input-Tokens – das sind für typische Coding-Nutzung grob 3–7 $/Monat.

**Kann ich OpenCode mit lokalen Modellen über Ollama nutzen?**

Ja. Setze `OPENAI_BASE_URL=http://localhost:11434/v1` und `OPENAI_API_KEY=ollama` in deiner OpenCode-Config. Wähle dann das lokale Modell in OpenCode. Unser [Ollama-Docker-Guide](/ollama-docker-install/) zeigt die Einrichtung von Ollama. Die Performance hängt von deiner Hardware ab – ein 7B-Modell bewältigt einfache Edits, aber komplexe Multi-File-Aufgaben brauchen mindestens ein 32B-Modell.

**Wie schneidet OpenCode im Vergleich zu Aider ab?**

Beide sind Terminal-Coding-Agents. OpenCode hat eine umfangreichere TUI mit Plan-Modus, Bild-Support und Sharing. Aider ist minimalistischer und hat eine stärkere Git-Integration. Aider unterstützt mehr obskure Modell-Provider. Für die meisten Entwickler ist OpenCode der bessere Daily Driver.

**Kann ich OpenCode neben Hermes Agent nutzen?**

Ja, die beiden ergänzen sich. OpenCode ist für Coding-Aufgaben – Dateien bearbeiten, Builds laufen lassen, Bugs fixen. Hermes Agent ist für breitere Aufgaben – Websuchen, geplante Jobs, Messaging, Serververwaltung. Betreibe beide auf demselben VPS.

**Welchen VPS brauche ich?**

Jeder Linux-VPS mit 1 GB+ RAM reicht. OpenCode selbst ist leichtgewichtig – die schwere Arbeit passiert beim API-Provider. Ein Hetzner CX22 für 6 $/Monat oder ein Äquivalent ist mehr als genug. Unser [VPS-Hosting-Vergleich](/vps-ai-coding-setup/) zeigt die Optionen.

Wenn du außerdem KI-Agents auf deinem Server betreibst, schau dir unseren [Hermes-Agent-Setup-Guide](/hermes-agent-setup-guide/) und die Zusammenstellung der [OpenClaw-Alternativen](/openclaw-alternatives/) an. Für die günstigsten Modelle für jedes dieser Tools deckt der Guide zu den [besten günstigen Modellen für Hermes Agent](/de/guenstige-hermes-agent-modelle/) Preise und Benchmarks ab. Für Alibabas neueste Qwen-3.6-Modelle, die hervorragend mit OpenCode funktionieren, siehe den Guide [Qwen 3.6 für KI-Coding-Agents](/qwen36-ai-coding-agents/). Wenn du einen minimalistischeren Terminal-Coding-Agent mit TypeScript-Erweiterungssystem willst, behandelt unser [Pi-Coding-Agent-Setup-Guide](/pi-coding-agent-setup-guide/) Installation, Modellkonfiguration und die besten Erweiterungen. Für einen detaillierten Vergleich dieser beiden Agents siehe den [OpenCode-vs.-Pi-Agent-Vergleich](/de/opencode-vs-pi-agent/). Für einen Deep Dive in OpenCode Gos Limits, Modelle (inklusive Grok 4.5 und Kimi K3) und ob sich das Abo lohnt, siehe das [Review zum OpenCode-Go-Plan für 10 $/Monat](/de/opencode-go-plan/). Du kannst OpenCodes kostenlose Modelle auch in [HyperFrames Studio](/de/hyperframes-studio-review/) einbinden, um animierte Shorts und Videos ohne zusätzliches Coding-Abo zu erzeugen. Die vollständige Landkarte der KI-GitHub-Projekte neben OpenCode: [Top-KI-GitHub-Repos](/de/top-ki-github-repos/).