--- title: "OpenCode 2 vs Pi Agent (1.0 & Durable): Welcher Coding-Agent gewinnt?" description: "Praxisvergleich von OpenCode 2 und Pi 1.0 (+ Pi Durable): Background-Daemon, Sub-Agents und Desktop-App vs Codemode, natives MCP und crash-sicherer State." date: 2026-04-30 categories: ["ai"] tags: ["ai-tools","self-hosted","llm"] --- *Hinweis: Dieser Artikel enthält Referral-/Affiliate-Links. Wenn du darüber kaufst, erhalte ich möglicherweise eine Provision – ohne zusätzliche Kosten für dich.* Ich fahre [OpenCode](/opencode-setup-guide/) und [Pi](/pi-coding-agent-setup-guide/) seit Monaten nebeneinander. Beide sind Open-Source-Terminal-Coding-Agents, beide hängen an günstigen Open-Weight-Modellen, und beide laufen zufrieden auf einem 6-Dollar-VPS. Anfang des Jahres war der Vergleich einfach: OpenCode war die TUI mit allem drum und dran, Pi das minimalistische Vier-Tool-Harness. Dann haben beide Projekte massive Rewrites geschifft. **OpenCode 2.0** wurde zu einem persistenten Background-Daemon mit eingebauten Sub-Agents, Git-Worktrees und einem Desktop-/Web-Client. **Pi 1.0** (jetzt unter Earendil, gebaut von Mario Zechner und Armin Ronacher) hat seine langjährige „kein MCP"-Haltung mit einer QuickJS-Sandbox namens **Codemode** umgedreht und **Pi Durable** für crash-sichere, always-on Background-Agents geschifft. Ich habe weiterhin beide installiert, und die Trennlinie zwischen ihnen ist jetzt schärfer als zum Launch. Hier ist, was sich geändert hat und wie sie heute dastehen. **Was dieser Artikel abdeckt** - Was sich in OpenCode 2.0 geändert hat (Daemon, Sub-Agents, Code Mode, Desktop-/Web-Pairing) und in Pi 1.0 + Pi Durable - Daemon-Architektur vs Pi Durables SQLite-/JSONL-Crash-Recovery - Aktualisierte Install-Befehle (`@opencode/cli` v2 und `@earendil-works/pi-coding-agent`) - Wie beide das MCP-Kontext-Bloat mit programmierbaren Sandboxes gelöst haben - Pricing mit GLM-5.3, MiniMax M3.1 Flash, DeepSeek V4.1 und OpenCode Go (31 Modelle) Für das Step-by-Step-Setup siehe den [OpenCode-Setup-Guide](/opencode-setup-guide/) und den [Pi-Coding-Agent-Setup-Guide](/pi-coding-agent-setup-guide/). ## Was sich Ende 2026 geändert hat: OpenCode 2.0 und Pi 1.0 Wenn du ältere Vergleiche dieser beiden Tools gelesen hast: Die Hälfte der Bulletpoints stimmt nicht mehr. - OpenCode 2.0 wurde ein Background-Daemon. Neu geschrieben in TypeScript und Effect fährt OpenCode 2 einen lokalen Daemon (Port `49374` auf Linux/macOS/WSL, `45278` auf Windows). Deine Terminal-TUI, die Beta-Desktop-App, die Web-UI (`opencode pair`) und `@opencode/sdk`-Scripts hängen alle am selben laufenden Service. - OpenCode 2 bekam Sub-Agents und Git-Worktrees. Version 1 hatte keine Sub-Agents. Version 2 liefert `@general`-, `@explore`- und `@scout`-Sub-Agents, die asynchron im Hintergrund laufen, plus Git-Worktree-Isolation, damit parallele Tasks dein aktuelles Checkout nicht zerlegen. - Pi 1.0 bekam natives MCP via Codemode. Über ein Jahr lang weigerte sich Pi, MCP in den Core zu bauen, weil rohe JSON-Tool-Schemas den Prompt aufblähten. Am 1. Oktober 2026 löste Pi 1.0 das mit Codemode: einer QuickJS-Sandbox, in der das Modell kurze JavaScript-Snippets schreibt, um MCP-Tools aufzurufen, zu filtern und zu parallelisieren – ohne rohe Outputs in den Chat-Transcript zu kippen. - Pi Durable (`@earendil-works/pi-durable`) erschien zusammen mit Pi 1.0. Es checkpointet jeden Model-Turn, jeden Tool-Call und jeden Compaction-Step nach SQLite, JSONL oder Cloudflare Durable Objects. Wenn ein Container neu startet oder dein VPS mitten im Task rebootet, nimmt der Prozess am exakten Speicherpunkt wieder auf – mit Idempotenz-Checks beim Tool-Replay. - Pi ist umgezogen zu `@earendil-works/pi-coding-agent`. Das Repo lebt unter `earendil-works/pi` und braucht Node.js 22.19+. ## Philosophie: Shared-Daemon-Workspace vs programmierbares Harness Auch nach beiden Updates hält die Kern-Trennlinie. OpenCode 2 will deine komplette Coding-Umgebung über Terminal, Browser und Desktop hinweg sein. Du installierst es, fährst `/connect`, und hast sofort `build`- und `plan`-Agents (Toggle mit `Tab`), `@explore`-Sub-Agents, `/init`, `/undo`, Image-Drag-and-Drop und Remote-Pairing (`opencode pair --remote`). Du schreibst kein TypeScript, damit es nützlich wird. Pi 1.0 startet weiterhin klein – `read`, `write`, `edit`, `bash`, eine Fullscreen-TUI und Codemode – und erwartet, dass du es formst. Persistentes Markdown-Memory, eigene Bash-Guards oder ein spezialisierter Review-Loop gefällig? Du legst `.ts`-Dateien in `~/.pi/agent/extensions/` ab. Und wenn du statt einer fertigen UI deinen eigenen Background-Agent-Daemon oder Multi-Tenant-Bot baust, gibt dir **Pi Durable** die State-Machine- und Crash-Recovery-Primitive als npm-Library. ## Installation Beachte die neuen v2-URLs für OpenCode und den neuen `@earendil-works`-Package-Scope für Pi 1.0 (das jetzt **Node.js 22.19+** braucht). ### OpenCode 2 ```bash curl -fsSL https://opencode.ai/v2/install | bash ``` Wenn du eine bestehende v1-Installation upgradest, führe `opencode upgrade --major` aus (v1 und v2 teilen sich den Binary-Namen `opencode`). Du kannst auch über npm (`npm i -g @opencode/cli@latest`), Homebrew (`brew install anomalyco/tap/opencode-v2`) oder Docker installieren: ```bash docker run -it --rm ghcr.io/anomalyco/opencode:2.0.0 ``` ### Pi 1.0 & Pi Durable Die empfohlene Installation für die Pi-1.0-CLI ist das offizielle Script: ```bash curl -fsSL https://pi.dev/install.sh | sh ``` Oder via npm, Bun oder Nix: ```bash # npm (requires Node.js 22.19+) npm install -g --ignore-scripts @earendil-works/pi-coding-agent # Nix nix profile add github:earendil-works/pi/stable ``` Wenn du mit **Pi Durable** einen crash-sicheren Background-Service oder eine eigene Agent-App baust, installiere die SDK-Packages in dein TypeScript-Projekt: ```bash npm install @earendil-works/pi-durable @earendil-works/pi-ai @earendil-works/chord ``` ## Architektur: OpenCode-2-Daemon vs Pi Durable Das ist der interessanteste technische Unterschied zwischen den beiden Ende 2026. Beide Teams haben erkannt, dass ein Coding-Agent, der an ein einzelnes interaktives TTY gebunden ist, stirbt, sobald deine SSH-Verbindung abreißt oder dein Laptop schläft – aber sie haben es von entgegengesetzten Enden gelöst. ### Wie OpenCode 2s Daemon funktioniert Wenn du `opencode` startest, fährt es einen Background-Daemon hoch, der lokal auf Port `49374` lauscht (oder `45278` auf Windows). Jedes Interface ist nur ein Client, der mit diesem Service redet: - Starte ein Refactoring in der Terminal-TUI - Führe `opencode pair` aus, um dieselbe Live-Session in der Web-UI oder der Beta-Desktop-App (macOS, Windows, Linux) zu öffnen - Nutze `opencode pair --remote`, um einen Ende-zu-Ende-verschlüsselten Tunnel zu bauen, der durch ein Server-Passwort geschützt ist – so checkst du eine Homeserver- oder VPS-Session von einer anderen Maschine aus - Steuere den Daemon programmatisch mit `@opencode/client` und `@opencode/sdk` ### Wie Pi Durable funktioniert Pi hat die `pi`-CLI als sauberen interaktiven Terminal-Runner behalten und langlebigen State in **`@earendil-works/pi-durable`** ausgelagert. Statt eines einzelnen lokalen Desktop-Daemons ist Pi Durable eine Execution-Engine für Agents, die Prozess-Crashes, Container-Redeploys oder Server-Reboots überleben müssen: - **Checkpointing auf Task-Ebene**: Jeder LLM-Call, jede Tool-Ausführung und jede Kontext-Compaction wird als diskreter Schritt nach SQLite, JSONL oder Cloudflare Durable Objects committed. - **Exakte Crash-Recovery**: Wenn dein Worker-Prozess mitten im Turn gekillt wird, öffnet ein neuer Prozess den SQLite-/JSONL-Store und macht genau da weiter, wo der unterbrochene Schritt aufgehört hat. - **Replay-Sicherheit (Idempotenz)**: Bei der Recovery nach einem Crash willst du nicht, dass ein Agent blind ein `git push`, eine Datenbank-Migration oder einen Stripe-Charge erneut ausführt. Pi Durable lässt Tools deklarieren, ob sie sicher auto-replay-bar sind. Idempotente Read-Tools laufen automatisch erneut; nicht-idempotente Tools spiegeln den unterbrochenen State zurück an das Modell, damit es inspizieren kann, was passiert ist, bevor es handelt. Wenn du eine fertige Multi-Client-App willst, die du heute mit deinem Browser paaren kannst, gewinnt OpenCode 2s Daemon. Wenn du deine eigenen Always-on-DevOps- oder Coding-Bots in TypeScript schreibst und transaktionale State-Recovery brauchst, ist Pi Durable für genau den Job gebaut. ## Modell-Support Beide Agents hängen an denselben günstigen Open-Weight-Modellen. ### OpenCode 2 OpenCode unterstützt 75+ Provider über *Models.dev* und lokale Engines wie Ollama und LM Studio. Setze deine Keys in `.env` oder führe `/connect` in der TUI aus. **Provider-API-Keys in lokalen Env-Vars halten** Am 17. Oktober 2026 hat OpenCode eine Breach seines Legacy-Console-Systems offengelegt, die gespeicherte Drittanbieter-API-Keys (OpenAI, Anthropic, Google) von ~1,4 % der Console-Nutzer exponierte. Lagere deine Provider-Keys lokal in `~/.config/opencode/.env` oder Umgebungsvariablen statt rohe Production-Keys in Third-Party-Web-Dashboards zu speichern. ### Pi 1.0 Pi unterstützt 20+ eingebaute Provider plus Custom-Endpoints in `~/.pi/agent/models.json` (das hot-reloadet, wenn du `/model` öffnest). Pi 1.0 führte außerdem **virtuelle Modelle** für Router-artiges Modell-Switching und verzögertes Tool-Loading ein. Beide Agents funktionieren out of the box mit OpenRouter und [OpenCode Go](https://go.bitdoze.com/opencode-go). Der [OpenCode-Go-Plan](/de/opencode-go-plan/) enthält jetzt **31 Modelle für 10 $/Monat** (plus einen Go-Plus-Tier für 40 $/Monat mit 2–4x höheren Limits), darunter GPT 6 Luna, GLM-5.3, DeepSeek V4.1 Flash, Kimi K3, MiniMax M3 und Qwen 3.8. Siehe den [Guide zu günstigen Modellen](/de/guenstige-hermes-agent-modelle/) und das [OpenCode-Go-Review](/de/opencode-go-plan/) für die exakten 5-Stunden-Request-Caps. ### Modelle, die ich mit beiden Agents fahre (Ende 2026) | Aufgabe | Modell | Typische API-Kosten | |------|-------|------------------| | Alltags-Edits in hohem Volumen | GLM-5.3-Flash / MiniMax M3.1-Flash | 0,15 $/M Input | | Schnelles agentisches Coding & Tools | DeepSeek V4.1 Flash | In Go enthalten (80-$-Cap) | | Harte Multi-File-Refactorings | GLM-5.3 | 1,40 $/M Input | | Long-Context-Repo-Chirurgie | DeepSeek V4 Pro / Kimi K3.1 Pro | 0,435–2,00 $/M Input | ## Workflow-Vergleich ### Plan-Modus OpenCode 2 hat `plan` und `build` als primäre Agents. Drück `Tab`, um zwischen Read-only-Planung und aktivem Dateieditieren zu wechseln. Pi hält Planung weiterhin modular über die `pi-plan`-Extension (oder LazyPi) – Read-only-Planung und Approval-Gates, sobald installiert. ### Code Mode vs Codemode: Wie beide das MCP-Bloat gefixt haben Das ist eine lustige Konvergenz: Beide Projekte haben fast exakt dieselbe Lösung für MCPs größten Makel geschifft – und ihr fast identische Namen gegeben. 30 MCP-Tools auf dem klassischen Weg anzuschließen kippt tausende Zeilen JSON-Schema in deinen System-Prompt, bevor du ein Wort getippt hast. Beide Agents umgehen das jetzt: - **OpenCode 2 „Code Mode"**: Stellt verbundene MCP-Server und -Tools als programmierbare JavaScript-Funktionen bereit, damit der Agent mehrere Operationen in einem Durchgang verketten und komponieren kann, statt Tokens auf Tool-Turn-Ping-Pong zu verbrennen. - **Pi 1.0 „Codemode"**: Fährt eine harness-seitige **QuickJS-Sandbox**. Natives MCP ist jetzt in Pi-1.0-Core eingebaut (kein `pi-mcp-adapter` nötig), und das Modell schreibt kurze JS-Scripts innerhalb der Sandbox, um MCP-Tools parallel aufzurufen, die Daten lokal zu filtern und nur das kompakte Ergebnis an die Konversation zurückzugeben. ### Sub-Agents und parallele Arbeit OpenCode 2 hat die Lücke hier geschlossen. Du bekommst eingebaute Sub-Agents – `@general`, `@explore` und `@scout` – an die der primäre Agent automatisch delegiert oder die du mit `@mentions` aufrufst. In Kombination mit OpenCode 2s Git-Worktree-Support laufen Background-Tasks und Builds asynchron, ohne dein Terminal zu blockieren. Pi handhabt parallele Agents über `pi-subagents` und seine Extension-API – oder auf Infrastruktur-Ebene via `@earendil-works/pi-durable` und `@earendil-works/chord`, wenn du Multi-Agent-Graphen in Code orchestrierst. ### Memory OpenCode 2 verlässt sich weiterhin auf `AGENTS.md` für statische Projektregeln und auf MCP-Memory-Server (wie [Hindsight](/de/hindsight-docker-deployment/) oder Cognee), wenn du sessionsübergreifendes Recall willst. Pi nutzt die `pi-memory-md`-Extension, um persistente Markdown-Notizen über dein Repo automatisch sessionübergreifend zu lesen und zu schreiben, während Pi Durable komplette Execution-Checkpoints nach SQLite oder JSONL persistiert. ### Sessions und CLI-Automatisierung OpenCode 2 gibt dir `/undo`, `/redo`, `/share`, Session-Syncing über TUI/Web/Desktop via dem lokalen Daemon und `opencode pair`. Pi gibt dir `/resume`, `/new`, `/tree`, `/fork` und `/clone`, um Konversationen wie eine Git-History zu branchen, plus `pi -p "prompt"` mit `--mode json` oder `--mode rpc` für CI-Pipelines und Shell-Scripts. ## Extensions und SDKs ### OpenCode 2 (`@opencode/sdk`) OpenCode 2 führte offizielle programmatische Packages ein – `@opencode/client` und `@opencode/sdk` –, die über die lokale HTTP-/WebSocket-API mit dem v2-Daemon reden. Beachte: Weil v2 ein Ground-up-Rewrite in Effect war, hatten Legacy-v1-Plugins Breaking Changes. ### Pi 1.0 (`~/.pi/agent/extensions/` + `pi-durable`) Pis TypeScript-Extension-System bleibt der einfachste Weg, an deinem eigenen interaktiven Agent zu hacken: Leg eine `.ts`-Datei in `~/.pi/agent/extensions/` ab, intercepte Tool-Calls, füge Slash-Commands oder eigene TUI-Widgets hinzu und führe `/reload` aus. [LazyPi](https://lazypi.org/) installiert weiterhin 60+ Skills und 76 Themes in einem Rutsch, und `pi-config` liefert fertige Bash-Guards und Web-Tools. ## Pricing Beide Agents sind kostenlose, MIT-/Open-Source-Software. Du zahlst nur für Modell-Tokens. | Setup | Monatliche Kosten | |-------|--------------| | GLM-5.3-Flash / MiniMax M3.1-Flash (API) | 2–8 $/Monat bei typischer Nutzung | | [OpenCode Go](/de/opencode-go-plan/) (31 Modelle, läuft in beiden) | 10 $/Monat (40 $/Monat Go Plus) | | GLM-5.3 / DeepSeek V4 Pro (direkt oder OpenRouter) | 10–25 $/Monat | | Claude Sonnet / Opus via Anthropic API | 20–60+ $/Monat | Ein [OpenCode-Go-Key](/de/opencode-go-plan/) funktioniert in OpenCode 2 und Pi 1.0 (`export OPENCODE_API_KEY=your-key`). ## Side-by-Side-Zusammenfassung (OpenCode 2 vs Pi 1.0) | Feature | OpenCode 2.0 | Pi 1.0 (+ Pi Durable) | |---------|--------------|-----------------------| | Kern-Architektur | Persistenter lokaler Daemon (Port `49374`) | Minimales CLI-Harness + optional `@earendil-works/pi-durable` | | Install-Package | `@opencode/cli` (`opencode.ai/v2/install`) | `@earendil-works/pi-coding-agent` (`pi.dev/install.sh`) | | UI-Flächen | Fullscreen-TUI, Web-UI, Desktop-App (Beta) | Fullscreen-TUI, JSON-/RPC-Headless-Modi | | Plan-Modus | Eingebaut (`Tab` zwischen `plan` und `build`) | Via `pi-plan`-Extension | | MCP-Support | Eingebaut mit JS **Code Mode** | Eingebautes natives MCP mit QuickJS **Codemode** | | Sub-Agents | Eingebaut (`@general`, `@explore`, `@scout`) + Git-Worktrees | Via `pi-subagents`-Extension oder `@earendil-works/chord` | | Crash-sicherer State | Daemon-Session-Persistenz | **Pi Durable** (SQLite / JSONL / Cloudflare DO + Replay-Safety) | | Modell-Provider | 75+ eingebaut | 20+ eingebaut + hot-reloadendes `models.json` + virtuelle Modelle | | `/init`-Bootstrap | Eingebaut (`AGENTS.md`) | Manuelles `AGENTS.md` oder `pi-config` | | Customizing | Config, MCP, `@opencode/sdk` | Hot-Reload-`.ts`-Extensions + 76 Themes | | OpenCode-Go-Support | Ja (31 Modelle) | Ja (31 Modelle) | ## Wann OpenCode 2 - Du willst direkt nach dem Install ein komplettes System ohne Extension-Suche - Du startest Tasks gern im Terminal und checkst sie in einem Browser- oder Desktop-Fenster via `opencode pair` - Du willst eingebaute `@explore`- und `@general`-Sub-Agents mit Git-Worktree-Isolation - Du willst `/init`, `/undo`, `/redo` und 75+ vorverdrahtete Provider out of the box ## Wann Pi 1.0 (und Pi Durable) - Du willst einen schnellen, minimalen Terminal-Agent, bei dem jedes Zusatzverhalten eine lesbare `.ts`-Datei ist, die du kontrollierst - Du magst Pi 1.0s QuickJS-**Codemode** zum Verketten von MCP-Tools ohne Kontext-Bloat - Du nutzt Conversation-Branching (`/tree`, `/fork`, `/clone`) und Headless-`pi -p`-Scripting - Du baust eigene langlebige Background-Agents oder Multi-User-Bots und brauchst **Pi Durables** SQLite-Checkpointing und idempotente Tool-Recovery ## Wann beide Ich fahre weiterhin beide auf demselben VPS. OpenCode 2 ist mein Default, wenn ich den `plan`-→-`build`-Loop, `@explore`-Sub-Agents im Hintergrund oder `opencode pair --remote` in einen Browser-Tab will. Zu Pi 1.0 greife ich, wenn ich eine abgespeckte Terminal-Session mit eigenen `.ts`-Extensions will – oder wenn ich einen durable Background-Workflow verdrahte, der es sich nicht leisten kann, bei einem Restart State zu verlieren. Beide teilen sich denselben `OPENCODE_API_KEY` und `OPENROUTER_API_KEY`. **Kann ich denselben API-Key für OpenCode 2 und Pi 1.0 nutzen?** Ja. Beide lesen `OPENROUTER_API_KEY` und `OPENCODE_API_KEY` aus deiner Umgebung. Ein 10-$-OpenCode-Go-Abo pro Monat funktioniert in beiden Tools und teilt sich dasselbe 5-Stunden- und Wochenkontingent. **Was ist Pi Durable – und brauche ich es für normales CLI-Coding?** Nein – wenn du `pi` einfach interaktiv in deinem Terminal fährst, speichert und resumed die Standard-`@earendil-works/pi-coding-agent`-CLI deine Chat-Transcripts schon. **Pi Durable** (`@earendil-works/pi-durable`) ist für Entwickler, die langlebige Background-Agents, Daemons oder Web-Apps bauen, wo der Agent Prozess-Crashes oder Server-Reboots überleben und unterbrochene Tool-Calls sicher replayen oder überspringen muss. **Wie upgrade ich von OpenCode v1 auf OpenCode 2?** Führe `opencode upgrade --major` aus oder installiere direkt mit `curl -fsSL https://opencode.ai/v2/install | bash`. Da v1 und v2 beide den Binary-Namen `opencode` nutzen, ersetzt v2 v1 in deinem PATH. Falls du Custom-v1-Plugins hattest, prüfe sie nach dem Upgrade – der v2-Effect-Rewrite brachte Breaking-API-Changes mit sich. **Hat Pi 1.0 wirklich nativen MCP-Support bekommen?** Ja. Nach über einem Jahr MCP-Verweigerung wegen Schema-Token-Bloat hat Pi 1.0 am 1. Oktober 2026 nativen MCP-Support via **Codemode** eingeführt. Statt jedes MCP-Schema in den Prompt zu kippen, schreibt das Modell JavaScript in einer QuickJS-Sandbox, um MCP-Tools lokal aufzurufen und zu filtern. **Kann ich beide auf demselben VPS fahren?** Ja. OpenCode 2 fährt seinen Background-Daemon standardmäßig auf Port `49374`, während Pi als Standalone-Prozess in deinem Verzeichnis läuft. Sie kommen sich nicht in die Quere. Für weitere Agent-Guides siehe den [Hermes-Agent-Setup-Guide](/hermes-agent-setup-guide/), den Artikel zu [GitHub-Copilot-Alternativen](/github-copilot-alternatives-2026/) und den Guide zu den [besten Open-Source-Modellen für OpenClaw](/best-opensource-models-for-openclaw/). Für den breiteren Tooling-Katalog siehe [60+ Top-AI-GitHub-Repos](/de/top-ki-github-repos/).