TL;DR: Pi in 5 Minuten zum Laufen bringen

Pi ist ein minimales, MIT-lizenziertes AI-Coding-Agent-Harness von Earendil, das in deinem Terminal lebt. Es bringt vier Tools mit — read, write, edit, bash —, spricht mit 15+ Modellanbietern, speichert jede Konversation als verzweigenden Session-Baum und wird über Extensions, Skills, Prompt-Templates und Packages erweitert statt über eine aufgeblähte Feature-Liste. Auf einem günstigen Netcup VPS wird daraus ein Always-on-Agent, in den du dich von jedem Rechner per SSH einwählen kannst.

Die wichtigsten Punkte zu Pi:

• Minimaler Kern, maximale Kontrolle — vier eingebaute Tools, alles andere ist optional
• 15+ Anbieter, hunderte Modelle — Anthropic, OpenAI, Google, Azure, Bedrock, Mistral, Groq, dazu lokale llama.cpp- und Ollama-Endpunkte
• Baumstrukturierte Sessions — jede Konversation verzweigen, forken, klonen, komprimieren und exportieren
• Headless-Modi — --print, --mode json und --mode rpc machen Pi aus Cron und CI heraus skriptbar
• Open Source — MIT-Lizenz, installierbar per Einzeiler, npm oder Nix
• Läuft hervorragend auf einem kleinen VPS — die schwere Arbeit erledigt das Modell remote, also reichen 4 vCores und 8 GB RAM völlig

Pi auf einem frischen Netcup VPS mit vier Befehlen installieren:

ssh root@your-server-ip
curl -fsSL https://pi.dev/install.sh | sh
pi --version
pi

Dann im TUI /login ausführen, den Anbieter wählen und loslegen.

Empfohlener Server: Netcup VPS 1000 G12.5 — 4 vCore, 8 GB ECC-RAM, 128 GB SSD, 2,5 Gbit/s mit Traffic-Flatrate, für EUR 12,18/Monat (zzgl. MwSt.).

Nutze einen dieser Gutscheincodes für 1 Monat gratis:

6877nc17913304870
6877nc17912005430
6877nc17911959135

Einleitung

Die meisten AI-Coding-Agents kommen mit einem bereits installierten Weltbild. Sie entscheiden, welche Tools existieren, wann um Erlaubnis gefragt wird, wie das Terminal aussieht und wo dein Gesprächsverlauf landet. Das funktioniert, bis dein Workflow nicht mehr zu dem passt, den sich der Hersteller vorgestellt hat — und dann kämpfst du gegen das Werkzeug, statt es zu benutzen.

Pi bezieht die Gegenposition. Der Slogan sagt es unmissverständlich: "There are many agent harnesses but this one is yours." Pi ist ein Harness, kein Produkt: ein kleiner, prüfbarer Kern, der Agent-Loop, Modellanfragen, Tool-Ausführung und Session-Speicherung übernimmt, während jedes meinungsstarke Verhalten in Extensions ausgelagert ist, die du selbst lädst.

Genau dieses Design macht Pi zu einem ungewöhnlich guten Kandidaten für das Selfhosting auf einem VPS. Der Agent selbst ist leichtgewichtig — die teure Inferenz läuft auf der Hardware deines Modellanbieters, nicht auf deiner. Was du wirklich vom Server brauchst, sind Uptime, eine stabile IP, schnelle Disk für Session-Dateien und Repositories sowie genug RAM, um Builds und Testsuiten neben dem Agent auszuführen. Ein Netcup VPS liefert exakt das zum Preis von zwei Kaffees im Monat — und mit den Gutscheincodes unten kann der erste Monat gratis sein.

Dieser Guide behandelt, was Pi ist, wie seine Architektur funktioniert, wie man es im Alltag benutzt, ein vollständiges Schritt-für-Schritt-Deployment auf Netcup und welche günstige Netcup-Server-Stufe zu welcher Art von Pi-Workload passt.

Was ist Pi?

Pi ist ein erweiterbarer AI-Agent, der aus deinem Terminal heraus arbeitet. Er kann Dateien inspizieren, Befehle ausführen, Inhalte bearbeiten und mehrstufige Aufgaben abarbeiten — das übliche Agent-Repertoire —, aber der Weg dorthin unterscheidet sich bewusst von der Konkurrenz.

Pi wird von Earendil Inc. entwickelt und unter der MIT-Lizenz veröffentlicht. Es ist in TypeScript geschrieben, wird als @earendil-works/pi-coding-agent auf npm verteilt und gehört mittlerweile zu den Agent-Projekten mit den meisten Stars auf GitHub, bei deutlich über einer Million npm-Downloads pro Woche. Der zweite Slogan — "Adapt Pi to your workflows, not the other way around" — ist die gesamte Produktthese.

Primitive statt Features

Der Standard-Pi-Agent bringt vier Tools mit: read, write, edit und bash. Mehr nicht. Es gibt kein eingebautes Sub-Agent-System, keinen Plan-Modus, keinen Berechtigungsdialog, kein im Kern verankertes Websuche-Tool.

Das ist kein Versehen. Diese Fähigkeiten existieren — als optionale Extensions. Sub-Agents, Plan-Modus und Permission-Gates sind alles Dinge, die du installierst, wenn du sie willst, und weglässt, wenn nicht. Das Ergebnis ist ein Kern, der klein genug bleibt, um ihn zu lesen, zu debuggen und ihm zu vertrauen — und ein Kontextfenster, das nicht mit Tool-Definitionen vollgeladen ist, die du nie benutzt.

Kernfunktionen

Modellzugriff über viele Anbieter Pi unterstützt 15+ AI-Anbieter und hunderte Modelle out of the box: Anthropic, OpenAI, Google, Azure, Amazon Bedrock, Mistral, Groq und mehr. Wechseln mit /model, durchschalten mit Ctrl+P, Standard speichern mit Ctrl+S. Preise, Kontextlimits und Fähigkeiten werden direkt im Selektor angezeigt.

Lokale und eigene Endpunkte Pi integriert sich direkt mit dem llama.cpp-Router für GGUF-Dateien über den Befehl /llama. Ollama, LM Studio, vLLM und jeder OpenAI-kompatible Endpunkt werden über einen Eintrag in models.json hinzugefügt. Auf einem größeren Netcup-Server heißt das: Du kannst Modelle lokal betreiben und die Inferenz vollständig auf eigener Hardware halten.

Baumstrukturierte Sessions Jede Konversation ist eine JSONL-Datei auf der Disk, in der jeder Eintrag eine ID und einen Parent hat. Jeder Pfad durch diesen Baum ist ein Branch. Du kannst ab einer früheren Nachricht weitermachen und damit einen neuen Branch in derselben Datei erzeugen, ausgewählte Historie in eine neue Session forken oder den aktiven Branch klonen — und nichts wird je zerstört.

Context Engineering Pi baut seinen System-Prompt aus Basisanweisungen plus gefundenen Kontextdateien zusammen: AGENTS.md, CLAUDE.md, SYSTEM.md für eine vollständige Ersetzung des System-Prompts und APPEND_SYSTEM.md für Ergänzungen. Compaction fügt einen Zusammenfassungseintrag ein, der ältere Nachrichten in folgenden Anfragen ersetzt, während die Originaleinträge unangetastet bleiben.

Steuerung in Echtzeit Pi unterscheidet Steering-Nachrichten (die nach dem aktuellen Turn einfließen) von Follow-up-Nachrichten (die einfließen, wenn alle ausstehende Arbeit fertig ist). Du kannst einen laufenden Agent umlenken, ohne ihn abzuschießen.

Vier Schnittstellen Interaktives TUI, --print für skriptbare Textausgabe, --mode json für einen JSONL-Event-Stream und --mode rpc für programmatische Steuerung — dazu ein TypeScript-SDK, um Pi in deine eigene Anwendung einzubetten.

Extensions, Skills, Prompts, Themes Extensions sind TypeScript-Module, die Befehle, Tools, Event-Hooks, Modellanbieter und MCP-Server registrieren. Skills sind Verzeichnisse mit einer SKILL.md, die bei Bedarf geladen werden. Prompt-Templates und Themes runden die Anpassungsfläche ab. Alle vier lassen sich als Packages bündeln und teilen.

Was Pi bewusst nicht tut

Pi fragt nicht vor jedem Tool-Aufruf um Erlaubnis und liefert keine eingebaute Sandbox. Es läuft mit den vollen Rechten des Benutzerkontos, das es gestartet hat. Die Dokumentation wird da sehr deutlich: "Safety comes from limiting the files, credentials, processes, and network services Pi can access."

Genau deshalb ist ein dedizierter VPS der richtige Ort für Pi. Statt einen ungesandboxten Agent auf deinen Laptop loszulassen — mit deinen SSH-Keys, deinem Passwortmanager, deinen privaten Dateien und deinen Produktions-Credentials alle nur einen bash-Aufruf entfernt — gibst du ihm einen Wegwerf-Server, der nur die Repositories und kurzlebigen Tokens enthält, die die Aufgabe tatsächlich braucht. Ein Netcup VPS für EUR 12,18/Monat ist ein günstiger, neu aufbaubarer Explosionsradius.

Wie man Pi benutzt

Das Terminal-UI

Pi läuft standardmäßig im Vollbild und teilt sich in drei Bereiche: ein Transkript der Prompts und Antworten, einen Editor zum Verfassen von Eingaben und eine Fußzeile mit Session-Metadaten, Kontextauslastung und aufgelaufenen Kosten. Die Rahmenfarbe des Editors spiegelt das aktuelle Thinking-Level wider — du weißt also immer, wie intensiv das Modell gerade arbeiten soll.

Slash-Befehle

Tippe /, um die Befehlspalette zu durchsuchen. Die, die du ständig brauchst:

Tastenkürzel, die man sich merken sollte

• Enter sendet, Shift+Enter fügt eine neue Zeile ein
• Alt+Enter reiht ein Follow-up nach der aktuellen Aufgabe ein
• Escape stoppt die laufende Aufgabe
• Ctrl+G öffnet deinen externen Editor für lange Prompts
• Ctrl+O klappt Tool-Ausgaben auf oder zu
• Ctrl+T schaltet Thinking-Blöcke um
• Ctrl+X kopiert die letzte Antwort
• Ctrl+L öffnet die Modellauswahl

Dateien referenzieren und Shell-Befehle ausführen

Tippe @, um Dateien zu suchen und anzuhängen, oder nutze Tab zur Pfadvervollständigung. In Terminals, die das unterstützen, lassen sich Bilder direkt in den Editor einfügen oder hineinziehen.

Stelle einer Zeile ein ! voran, um einen Shell-Befehl auszuführen und seine Ausgabe in die Konversation aufzunehmen. Mit !! läuft der Befehl, ohne das Ergebnis mit dem Modell zu teilen — praktisch, um mitten in einer Session etwas privat nachzusehen.

Konfigurationsaufbau

Pi nutzt ein zweistufiges Konfigurationssystem. Das Agent-Verzeichnis liegt standardmäßig unter ~/.pi/agent und lässt sich mit PI_CODING_AGENT_DIR verschieben:

~/.pi/agent/
  settings.json        # Benutzereinstellungen und Ressourcenpfade
  keybindings.json     # eigene Tastenkürzel
  mcp.json             # projektübergreifend verfügbare MCP-Server
  models.json          # eigene Endpunkte und Modelldefinitionen
  auth.json            # gespeicherte API-Keys und OAuth-Credentials
  AGENTS.md            # benutzerweite Anweisungen
  SYSTEM.md            # vollständiger Ersatz des System-Prompts
  APPEND_SYSTEM.md     # ergänzende Anweisungen
  extensions/ skills/ prompts/ themes/

Ein Projektverzeichnis unter .pi/ spiegelt diese Struktur für Overrides pro Repository und wird erst geladen, nachdem du Project Trust erteilt hast. Die vertrauenswürdige Projektdatei hat Vorrang vor der entsprechenden Datei im Agent-Verzeichnis.

Skills

Ein Skill ist ein Verzeichnis mit einer SKILL.md samt YAML-Frontmatter — name, description, license, compatibility, disable-model-invocation — plus allen Skripten, Referenzen und Assets, die er braucht.

Beim Start scannt Pi die konfigurierten Skill-Verzeichnisse und fügt Name, Beschreibung und Pfad jedes Skills in den System-Prompt ein. Die vollständigen Anweisungen werden erst geladen, wenn der Skill tatsächlich gebraucht wird — so bleiben Detailvorgaben aus dem Kontext, bis sie relevant sind. Skills werden in ~/.agents/skills/ und .agents/skills/ gefunden, rekursiv durchsucht und an Repository-Wurzeln gestoppt.

Die Leitregel aus der Doku: "Use a skill when a workflow needs more context than a prompt template but does not need a new executable integration point."

Extensions

Extensions sind TypeScript- oder JavaScript-Module in ~/.pi/agent/extensions/. Eine minimale sieht so aus:

export default function (pi: ExtensionAPI) {
  pi.registerCommand("hello", {
    description: "Show a greeting",
    handler: async (name, ctx) => {
      ctx.ui.notify(`Hello, ${name || "world"}!`, "info");
    },
  });
}

Während der Entwicklung lädst du eine direkt mit pi --extension ./hello.ts. Pi nutzt jiti, um TypeScript ohne Build-Schritt zu kompilieren.

Extensions registrieren sich über pi.registerCommand(), pi.registerTool(), pi.registerProvider(), pi.registerMcpServer() und pi.on() für Lifecycle-Events wie session_start, before_agent_start, tool_call und message_end. Langlebige Ressourcen sollten aus session_start heraus starten, nicht aus der Factory-Funktion, weil manche Aufrufe die Session-Initialisierung überspringen.

Extensions laufen innerhalb des Pi-Prozesses mit vollen OS-Rechten. Lade sie nur aus Quellen, denen du vertraust.

Packages

Ein Package bündelt Extensions, Skills, Prompts und Themes zu einer verteilbaren Einheit — ein gewöhnliches Verzeichnis oder npm-Package:

pi install npm:@example/[email protected]
pi install git:github.com/example/pi-tools@v1
pi install ./local-package
pi list
pi remove <source>
pi update --extensions

Zum Testen ohne Installation: pi -e npm:@example/pi-tools. Veröffentlicher fügen das Keyword pi-package zu den npm-Metadaten hinzu, damit das Package in der Galerie auffindbar ist.

Headless-Modi für Automatisierung

Hier zahlt sich ein selbstgehostetes Pi auf einem VPS richtig aus. Die nicht-interaktiven Modi machen Pi zu einer skriptbaren Komponente:

# Print-Modus: Prompts ausführen, finalen Text nach stdout schreiben, beenden
pi --print "Summarise the open TODOs in this repo"

# JSON-Modus: einen JSONL-Event-Stream zum Parsen ausgeben
pi --mode json "Run the test suite and report failures"

# RPC-Modus: JSONL-Befehle von stdin lesen, Antworten herausstreamen
pi --mode rpc

Nützliche Flags für unbeaufsichtigte Läufe:

Kombiniere --print mit -t und --approve in einem Cronjob, und dein Netcup VPS wird zum autonomen Wartungsarbeiter: nächtliche Dependency-Audits, Changelog-Entwürfe, Log-Triage, geplante Refactorings.

Wie der Agent-Loop tatsächlich funktioniert

Den Loop zu verstehen hilft beim Debuggen und Tunen:

1. Eingabe — eine abgeschickte Nachricht wird Teil des aktiven Konversations-Branches
2. Request-Aufbau — Pi setzt System-Prompt, aktiven Branch, verfügbare Tools und Modelleinstellungen zusammen
3. Antwort — der Anbieter streamt Text und Tool-Aufrufe zurück
4. Tool-Ausführung — Pi protokolliert die Antwort, führt jeden Tool-Aufruf aus und protokolliert die Ergebnisse
5. Loop-Steuerung — steht noch Arbeit aus, folgt ein weiterer Turn; sonst ist der Lauf beendet

Tools und Extensions laufen innerhalb des Pi-Prozesses, mit den Betriebssystemrechten dieses Prozesses. Es gibt keine separate Sandbox-Schicht, außer du baust eine — genau das tut der Containerisierungsschritt im Quick Start weiter unten.

Quick Start: Pi auf einem Netcup VPS deployen

Schritt 1: Netcup-Server bestellen

Gehe auf netcup.com, wähle den VPS 1000 G12.5 (4 vCore, 8 GB ECC-RAM, 128 GB SSD, 2,5 Gbit/s) und löse beim Checkout einen Gutschein ein:

6877nc17911959133
6877nc17911959132
6877nc17911959130

Wähle ein Rechenzentrum in deiner Nähe — Nürnberg, Wien, Amsterdam, Manassas oder Singapur —, denn TUI-Latenz über SSH ist das, was du jeden Tag spürst. Nimm ein aktuelles Ubuntu LTS oder Debian Image. Die Bereitstellung dauert üblicherweise wenige Minuten, danach erscheinen deine Zugangsdaten im netcup Customer Control Panel.

Wenn dir EUR 5 Rabatt auf jede Bestellung lieber ist als ein Gratismonat, nutze 36nc17718015540.

Schritt 2: Erster Login und Server-Härtung

Pi läuft mit den vollen Rechten deines Accounts — härte die Maschine also vor der Installation:

ssh root@your-server-ip

apt update && apt upgrade -y
adduser pi
usermod -aG sudo pi

# SSH-Key zum neuen Benutzer kopieren
rsync --archive --chown=pi:pi ~/.ssh /home/pi/

Deaktiviere Passwort-Login und Root-SSH in /etc/ssh/sshd_config:

PermitRootLogin no
PasswordAuthentication no

Dann SSH neu starten und die Firewall aktivieren:

systemctl restart ssh
ufw allow OpenSSH
ufw enable

Melde dich ab jetzt als Benutzer pi an. Netcups Out-of-Band-Remote-Konsole im Control Panel ist dein Sicherheitsnetz, falls du dich je aussperrst.

Schritt 3: Node.js und Abhängigkeiten installieren

Pi benötigt Node.js 22.19 oder neuer. Installiere es zusammen mit den Tools, die Pis bash-Tool erwartet:

sudo apt install -y curl git ripgrep ca-certificates tmux
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs
node --version   # muss v22.19.0 oder höher melden

Schritt 4: Pi installieren

Wähle einen von drei Installationswegen.

Install-Skript (empfohlen):

curl -fsSL https://pi.dev/install.sh | sh

npm:

npm install -g --ignore-scripts @earendil-works/pi-coding-agent

Nix:

nix profile add github:earendil-works/pi/stable

Installation prüfen:

pi --version

Schritt 5: Authentifizieren und Modell wählen

Wechsle in ein Arbeitsverzeichnis und starte das TUI:

mkdir -p ~/workspace && cd ~/workspace
pi

Führe in Pi /login aus, wähle deinen Anbieter und folge den Anweisungen. Die Credentials landen in ~/.pi/agent/auth.json.

Für Headless- und CI-Nutzung überspringst du gespeicherte Credentials komplett und exportierst stattdessen die Anbieter-Umgebungsvariable — Pi löst Credentials in dieser Reihenfolge auf: --api-key-Flag, dann auth.json, dann das Feld apiKey in models.json, dann Umgebungsvariablen oder vorhandene Cloud-Credentials:

echo 'export ANTHROPIC_API_KEY="sk-..."' >> ~/.bashrc
source ~/.bashrc

Dann /model ausführen, um nach funktionierender Authentifizierung gefilterte Modelle zu durchsuchen. Ctrl+S speichert deinen Standard, Ctrl+P schaltet durch.

Schritt 6: tmux einrichten, damit Pi Verbindungsabbrüche überlebt

Das ist der wertvollste Schritt für einen Remote-Server. Ohne tmux beendet eine abgebrochene SSH-Verbindung deinen Agent mitten in der Aufgabe.

tmux braucht außerdem Extended Keys, sonst meldet es Shift+Enter, Ctrl+Enter und einfaches Enter als dieselbe Taste. Ergänze ~/.tmux.conf (tmux 3.5+):

set -g extended-keys on
set -g extended-keys-format csi-u

Bei tmux 3.2–3.4 nur die erste Zeile verwenden. Server neu starten und eine benannte Session beginnen:

tmux kill-server
tmux new -s pi

Prüfe, dass Shift+Enter Zeilenumbrüche einfügt, Enter absendet und Alt+Enter Follow-ups einreiht. Jetzt mit Ctrl+B D abkoppeln, Laptop zuklappen und später von überall wieder verbinden:

tmux attach -t pi

Schritt 7: Projektkontext einrichten

Pi liest Kontextdateien, um deine Konventionen zu verstehen. Lege eine benutzerweite ~/.pi/agent/AGENTS.md für immer gültige Dinge an und eine AGENTS.md pro Repository für Projektspezifisches:

cd ~/workspace/my-project
cat > AGENTS.md <<'EOF'
# Project conventions

- Package manager: pnpm
- Run tests with `pnpm test`, lint with `pnpm lint`
- Never commit directly to main; branch first
- Keep changes minimal and match surrounding style
EOF

Starte Pi und referenziere Dateien mit @:

Review @src/auth.ts for session handling bugs and propose a fix.

Schritt 8: Für eine echte Sandbox containerisieren

Weil Pi kein eingebautes Berechtigungssystem hat, ist Containerisierung die stärkste praktikable Isolation. Auf einem VPS ist das eine günstige Versicherung: Der Container schützt Host-Ressourcen, die du nicht explizit freigegeben hast.

Installiere Docker und lege Dockerfile.pi an:

FROM node:24-bookworm-slim

RUN apt-get update \
  && apt-get install -y --no-install-recommends bash ca-certificates git ripgrep \
  && rm -rf /var/lib/apt/lists/*
RUN npm install -g --ignore-scripts @earendil-works/pi-coding-agent

WORKDIR /workspace
ENTRYPOINT ["pi"]

Bauen und starten:

docker build -t pi-sandbox -f Dockerfile.pi .

docker run --rm -it \
  -e ANTHROPIC_API_KEY \
  -v "$PWD:/workspace" \
  -v pi-agent-home:/root/.pi/agent \
  pi-sandbox

Der Mount $PWD:/workspace gibt nur das aktuelle Projekt frei. Das benannte Volume pi-agent-home behält containerlokale Einstellungen, Credentials und Sessions zwischen Läufen. Prüfe die Grenze aus Pi heraus mit !pwd — es sollte /workspace ausgeben. Mounte dein Host-~/.pi/agent nicht, außer du brauchst gezielt die vorhandene Konfiguration.

Schritt 9: Einen geplanten Agent-Job ergänzen

Mit Pi auf einem Always-on-Netcup-VPS lässt sich autonome Arbeit planen. Lege einen Cron-Eintrag an:

crontab -e

0 3 * * * cd /home/pi/workspace/my-project && /usr/local/bin/pi --print --approve \
  -t read,bash "Check for outdated dependencies and write findings to AUDIT.md" \
  >> /home/pi/pi-cron.log 2>&1

Beachte die Allowlist -t read,bash: Der Job darf inspizieren und Befehle ausführen, aber keine beliebigen Dateien schreiben oder bearbeiten. Beschränke Tools auf das Minimum, das jeder Job braucht.

Schritt 10: Optional — Modelle lokal betreiben

Auf einem größeren Netcup-Server kannst du die Inferenz auf eigener Hardware halten. Pi unterstützt den llama.cpp-Router nativ über /llama. Für Ollama, LM Studio oder vLLM trägst du sie in ~/.pi/agent/models.json ein:

{
  "providers": {
    "ollama": {
      "baseUrl": "http://localhost:11434/v1",
      "api": "openai-completions",
      "apiKey": "ollama",
      "models": [{ "id": "qwen2.5-coder:7b" }]
    }
  }
}

Der Dummy-API-Key genügt Pi; Ollama ignoriert ihn. Für authentifizierte Endpunkte nutze $NAME-Interpolation aus Umgebungsvariablen statt literaler Werte.

Schritt 11: Sessions sichern

Sessions liegen in ~/.pi/agent/sessions/, nach Arbeitsverzeichnis sortiert. Es ist schlichtes JSONL — leicht zu archivieren:

tar czf ~/pi-sessions-$(date +%F).tar.gz ~/.pi/agent/sessions

Kombiniere das mit netcup-Snapshots aus dem Control Panel für Wiederherstellungspunkte des gesamten Servers vor riskanten Upgrades.

Den richtigen Netcup-Server für günstiges Pi-Hosting wählen

Pis eigener Ressourcenbedarf ist bescheiden — es ist ein Node.js-Prozess, der Tokens von einer Remote-API streamt. Was deinen Server wirklich belastet, sind die Befehle, die Pi ausführt: Builds, Testsuiten, Docker-Images, Language Server und, wenn du lokal gehst, Modellinferenz.

So ordnet sich die aktuelle netcup VPS G12.5-Reihe den Pi-Workloads zu.

VPS-Vergleich für Pi

Alle Stufen enthalten IPv4 + IPv6, eine Traffic-Flatrate, Snapshots, DDoS-Schutz, vollen Root-Zugriff und eine Out-of-Band-Remote-Konsole. Standorte: Nürnberg, Wien, Amsterdam, Manassas, Singapur.

Empfohlene Konfigurationen

VPS 1000 G12.5 — die Standardwahl für Pi

4 vCores, 8 GB ECC-RAM, 128 GB SSD für EUR 12,18/Monat. Das trägt Pi bequem mit ein paar Repositories, ripgrep-Suchen über große Codebasen, Node- oder Python-Testsuiten und einer tmux-Session, die du wochenlang angehängt lässt. Wenn du Modelle von Anthropic, OpenAI oder Google nutzt, ist das alles, was Pi an Server braucht.

Gutscheine für 1 Monat gratis:

6877nc17913304870
6877nc17912005430
6877nc17911959135

VPS 2000 G12.5 — containerisiert und für mehrere Projekte

8 vCores, 16 GB ECC-RAM, 256 GB SSD für EUR 22,62/Monat. Die richtige Stufe, sobald du Pi in Docker-Sandboxes betreibst, mehrere Projektcontainer warm hältst oder Builds fährst, die Parallelität wirklich nutzen. 16 GB lassen Luft für eine Datenbank und einen Language Server neben dem Agent.

Gutscheine für 1 Monat gratis:

6878nc17911959164
6878nc17911959163
6878nc17911959162

VPS 4000 G12.5 — parallele Pi-Sessions und CI

12 vCores, 32 GB ECC-RAM, 512 GB SSD für EUR 38,11/Monat. Betreibe mehrere unabhängige Pi-Sessions gegen verschiedene Branches, jede im eigenen Container, plus einen CI-Runner auf derselben Maschine. Die 512 GB SSD schluckt Docker-Layer-Caches, node_modules-Bäume und monatelanges Session-JSONL ohne Aufräumen.

Gutscheine für 1 Monat gratis:

6879nc17911959185
6879nc17911959183
6879nc17911959182

VPS 8000 G12.5 — Team-Harness und lokale Inferenz

16 vCores, 64 GB ECC-RAM, 1 TB SSD für EUR 56,39/Monat. Die Spitze der Reihe mit geteilten Kernen. Genug RAM, um mittelgroße GGUF-Modelle über llama.cpp oder Ollama bereitzustellen, während mehrere Entwickler ihre eigenen Pi-Sessions über SSH fahren, jeder mit separatem Agent-Verzeichnis.

Gutscheine für 1 Monat gratis:

6880nc17911959204
6880nc17911959203
6880nc17911959202

Root Server: dedizierte Kerne für berechenbare Agent-Läufe

Wenn Pi planmäßig Testsuiten oder Kompilierungen fährt, nehmen dedizierte Kerne die Schwankungen geteilter CPU heraus. Netcups Root Server G12.5-Reihe nutzt AMD-EPYC-9645-Kerne mit NVMe-Speicher.

RS 1000 G12.5 — EUR 18,26/Monat, 1 Monat gratis:

6874nc17911959062
6874nc17911959061
6874nc17911959060

RS 2000 G12.5 — EUR 34,20/Monat, 1 Monat gratis:

6875nc17911959082
6875nc17911959081
6875nc17912005420

RS 8000 G12.5 — EUR 124,72/Monat, 1 Monat gratis:

6876nc17911959104
6876nc17911959103
6876nc17911959102

Wie man sich entscheidet

Starte mit dem VPS 1000 G12.5. Pis Agent-Prozess ist klein; der Server existiert, um deine Toolchain auszuführen. Rüste erst auf, wenn du an eine echte Wand stößt:

• RAM reicht bei Builds nicht — wechsle zum VPS 2000 G12.5
• Builds fühlen sich zu Stoßzeiten uneinheitlich an — wechsle zu einem Root Server mit dedizierten Kernen
• Mehr als zwei oder drei gleichzeitige Pi-Container — wechsle zum VPS 4000 G12.5
• Lokale GGUF-Modelle über /llama — geh direkt zum VPS 8000 G12.5 oder RS 8000 G12.5, wo RAM der begrenzende Faktor ist

Speicher dimensionieren. Session-JSONL-Dateien sind winzig. Was wächst, sind Docker-Layer, Dependency-Caches und geklonte Repositories. 128 GB sind großzügig für eine Handvoll Projekte; wenn du große Monorepos spiegelst, geh eine Stufe höher oder ergänze netcup Local Block Storage.

Standort. Nimm das nächstgelegene Rechenzentrum. Das Pi-TUI ist interaktiv und jeder Tastendruck geht übers Netz — 20 ms fühlen sich sofort an, 200 ms nicht.

Kosten optimieren

1. Löse bei jeder Erstbestellung einen Gutschein ein. Ein Gratismonat auf einem VPS 2000 G12.5 sind EUR 22,62, die du behältst.
2. Nutze stundenweise Abrechnung für Experimente. Server hochfahren, eine Pi-Extension testen, wieder löschen.
3. Binde dich für 12 Monate, um den niedrigsten Monatspreis zu bekommen, sobald dein Setup steht.
4. Klein anfangen und hochskalieren. Netcup macht Upgrades unkompliziert; am ersten Tag zu groß zu kaufen, ist verschenktes Geld.
5. Kombiniere 36nc17718015549 für EUR 5 Rabatt auf jede Bestellung, wenn für deine Wunschstufe kein Gratismonat-Gutschein gilt.

Gutschein-Übersicht

Weitere aktuelle Codes findest du immer auf netcup.best.

Fazit

Pi ist das Agent-Harness für Leute, die ihr Werkzeug verstehen und kontrollieren wollen. Ein Kern mit vier Tools, ein dokumentierter Agent-Loop, Sessions als lesbare JSONL-Bäume und eine Extension-API, mit der du genau die Fähigkeiten ergänzt, die du brauchst — Sub-Agents, Plan-Modus, Permission-Gates — statt fremde Defaults zu erben. Es ist MIT-lizenziert, installiert sich mit einem Befehl und spricht mit 15+ Modellanbietern plus jedem lokalen Endpunkt, auf den du es richtest.

Dieselbe Minimalität trägt einen Kompromiss, den Pi offen benennt: keine eingebaute Sandbox, keine Freigabe pro Aufruf, volle Benutzerrechte. Es auf dem eigenen Rechner zu betreiben heißt, einem LLM-gesteuerten bash-Tool die Schlüssel zu allem zu geben, was dir gehört.

Pi auf einem Netcup VPS selbst zu hosten löst das sauber. Ein dedizierter Server ist ein kontrollierter Explosionsradius — er enthält nur die Repositories und kurzlebigen Credentials, die eine Aufgabe wirklich braucht, er lässt sich vor jeder riskanten Aktion snapshotten und in Minuten komplett neu aufbauen, wenn etwas schiefgeht. Leg Docker-Containerisierung obendrauf und du hast die Isolation, die Pi bewusst dem Betreiber überlässt.

Die praktischen Vorteile summieren sich schnell:

• Immer an. Starte ein langes Refactoring in tmux, klapp den Laptop zu, verbinde dich morgen vom Handy wieder.
• Wirklich isoliert. Der Agent fasst einen Wegwerf-Server an, nicht dein persönliches Dateisystem, deine SSH-Keys oder deinen Passwortmanager.
• Automatisierbar. --print, --mode json und --mode rpc plus Cron machen deinen VPS zum autonomen Wartungsarbeiter, der seinen eigenen Tool-Zugriff beschränkt.
• Schnell und nah an deinen Daten. 2,5 Gbit/s mit Traffic-Flatrate, NVMe- oder SSD-Speicher und fünf Rechenzentrumsstandorte.
• Wiederherstellbar. Snapshots, eine Out-of-Band-Remote-Konsole und voller Root-Zugriff bedeuten: keine Aussperrung ist endgültig.
• Privat by default. Mit einem lokalen llama.cpp- oder Ollama-Endpunkt auf einer größeren Stufe verlässt dein Code nie eine Infrastruktur, die du kontrollierst.

Und es ist günstig. Ein VPS 1000 G12.5 für EUR 12,18/Monat trägt Pi, deine Toolchain und deine Repositories mit Luft nach oben — weit weniger als ein einzelner Monat der meisten gehosteten AI-Entwicklungsplattformen, und dir gehört der ganze Stack. Mit einem Gutschein kostet der erste Monat nichts:

6877nc17911959132
6877nc17911959130
6877nc17913304870

Pis Versprechen lautet, dass das Harness dir gehört. Dann stell es auch auf einen Server, der dir gehört.