Pi Coding Agent Installation 2026: npm, API-Keys und Claude/GPT/Gemini in TypeScript

Warum das „nächste IDE-Agent“ Multi-Modell nicht löst

2026 fehlt den meisten Teams nicht „ein Agent“. Es fehlt die Trennung: Schlüssel, Modell und Ausführung hängen in demselben Produkt. Claude Code frisst das Anthropic-Abo, Codex CLI das ChatGPT-Konto, Cursor versteckt die Modellwahl hinter dem Editor-Login. Nachmittags wollen Sie mit Claude die Architektur anfassen, abends mit Gemini Tests scannen, am Wochenende mit GPT Commit-Texte schreiben — und jedes Mal wechseln Fenster, Rechte und Kontext.

Das ist keine Komfortfrage. Es ist eine Buchhaltungs- und Betriebsfrage. Sobald der Schlüssel in einem Abo-Fenster sitzt, ist der Workflow Eigentum des Anbieters. Eine neue IDE ändert daran nichts: Sie kaufen nur ein weiteres Fenster, in dem wieder ein Modell fest verdrahtet ist. Wer drei Rechnungen hat, braucht drei Einstiege — oder ein Harness, das die Rechnungen als austauschbare Backends behandelt.

Pi zerlegt genau diese Annahme. Die offizielle Position ist ein minimales Harness: standardmäßig bekommt das Modell nur read, write, edit und bash. Sub-Agent, Plan Mode, Rechte-Gates und MCP — Funktionen, die andere fest einbauen — werden zu Extensions, Skills oder Pi Packages, die Sie nach dem eigenen Workflow nachladen. Das Modell ist austauschbares Backend, nicht das Produkt.

Viele Teams übersehen das, weil die Demo so schlicht wirkt. Keine bunten Plan-Karten, keine eingebaute Agentenarmee. Genau das ist der Punkt: Wer die dicke Schicht zuerst kauft, kauft auch die Bindung. Wer die dünne Schicht zuerst installiert, kann später Skills nachziehen, ohne den Einstieg neu zu schreiben. Die Lernkurve liegt nicht im Prompt, sondern in der Entscheidung, wo Schlüssel, Regeln und Ausführung wohnen.

Die asymmetrische Schlussfolgerung lautet: Die Grenze liegt nicht darin, ob Claude, GPT oder Gemini stärker ist, sondern ob das Harness das Modell als austauschbares Ausführungs-Backend behandelt und sich ins eigene TypeScript-Projekt schieben lässt. Weiterentwickeln müssen Sie Einstieg (CLI / SDK / RPC), Schlüssel-Schichtung und einen dauerhaften Ausführungsknoten — nicht schon wieder eine dickere IDE. Die Begriffszerlegung „was ein Harness ist“ steht in Omnigent Agent Harness 2026 erklärt; dieser Text löst nur: Pi installieren, drei Schlüssel anbinden, ins Repo schreiben.

Was Pi ist: vier Einstiege ins minimale Harness

Erst einordnen, dann Befehle. Pi ist kein weiteres Chat-Fenster, sondern vier Öffnungen derselben Agentenschleife. Die Dimensionen bleiben Einstieg, Ausführung, Kontext und Zielgruppe. Wenn Sie diese vier Spalten im Kopf behalten, hören die Feature-Listen auf, sich wie Marketing anzuhören: Jede Form macht dieselbe Schleife zugänglich, nur für einen anderen Host.

Im Alltag merken Sie den Unterschied sofort. Das TUI ist für Menschen, die mitten im Refactor die Richtung ändern. Print/JSON ist für Makefile und CI, die keine Tastatur haben. RPC ist für Gateways, die nicht in Node leben. Das SDK ist für das Repository, das den Review nachts selbst anstoßen soll. Wer nur eine Form kennt, behandelt Pi wie „noch eine CLI“ — und verpasst den Grund, warum es sich lohnt, den Schlüssel aus dem Abo-Fenster zu ziehen.

Die Website formuliert die Philosophie klar: Ändern Sie das Harness, nicht Ihren Workflow. Extensions sind TypeScript-Module und registrieren Werkzeuge, Slash-Befehle, Tastenkürzel und TUI-Bausteine. Skills werden bedarfsgerecht geladen, damit der Prompt-Cache nicht sofort platzt. Pakete kommen über pi install npm:@scope/pkg oder pi install git:host/user/repo. Die vollständige Fähigkeitsliste steht auf pi.dev und in der npm-Paketbeschreibung; Versionsnummern ändern sich, die Befehlsform ist stabiler als „der Modellname vom 16. September“.

Pi vs. geschlossene Agenten: Einstieg, Ausführung, Kontext

Wenn Sie bei der Auswahl zuerst fragen „Ist Claude stärker oder GPT?“, verpassen Sie den eigentlichen Unterschied. Legen Sie Pi, offizielle CLIs und IDE-Agenten auf dieselbe Tabelle — nach Einstieg, Ausführung, Kontext und Zielgruppe — und das Urteil dreht sich fast sofort. Dieser Text macht keine Rangliste. Er beantwortet nur, ob Sie den Schlüssel aus dem Produkt ziehen sollten. Wer ohnehin bei einem Anbieter bleiben will, spart sich die Harness-Steuer; wer zwei Rechnungen hat, merkt sie sofort.

Der Preis der geschlossenen Agenten ist nicht nur die Monatsgebühr. Es ist die Unfähigkeit, denselben Review-Prompt einmal mit Claude und einmal mit Gemini zu fahren, ohne Fenster, Regeln und Werkzeuggrenzen neu zu bauen. Der Preis von Pi ist umgekehrt: Sie müssen Schlüssel, Limits und Trust-Politik selbst pflegen. Das ist kein Nachteil, wenn Sie sowieso mehrere Anbieter bezahlen. Es ist ein Nachteil, wenn Sie nur ein Abo haben und eine fertige Erfahrung wollen.

Die Abwägung von Claude Code und Codex auf einem Remote-Mac steht in Claude Code vs. Codex: Remote-Mac-Entwicklungsumgebung. Jene Texte beantworten „welche offizielle CLI“; dieser Text beantwortet: Wenn Multi-Modell feststeht und die Schleife in TypeScript soll, wie wird das Harness installiert.

npm-Installation und API-Key-Konfiguration

Globale CLI: erst sprechen, dann einbetten

Offizielle Empfehlung: globale Installation mit --ignore-scripts. Der Normalbetrieb von Pi hängt nicht an Install-Lifecycle-Skripten der Abhängigkeiten; das Überspringen senkt das Lieferkettenrisiko. Die Node-Version folgt Ihrer lokalen LTS. Die Engine-Angabe im Paket wandert mit Updates — schreiben Sie keine Minor-Version aus einem Blogeintrag in den Vertrag.

Zwei Minuten nach der Installation entscheiden über den Rest der Woche. Entweder liegt pi im PATH und Sie sehen eine Versionszeile, oder Sie debuggen später in CI, warum der Runner „command not found“ wirft. Auf einem Cloud-Mac gehört dieser Schritt ins Image, nicht in die Erinnerung des letzten SSH-Logins. Wer den Befehl nur lokal kennt, wird ihn in der Pipeline neu erfinden — und dann die falsche Node-Version mitnehmen.

npm install -g --ignore-scripts @earendil-works/pi-coding-agent
# oder: pnpm add -g --ignore-scripts @earendil-works/pi-coding-agent
# oder: bun add -g --ignore-scripts @earendil-works/pi-coding-agent
# Installer-Alternative: curl -fsSL https://pi.dev/install.sh | sh
pi --version

Danach zwei Checks: pi liegt im PATH; mindestens ein Schlüssel oder ein /login ist vorbereitet. Ohne Credentials öffnet sich das TUI, der Modellkatalog bleibt aber leer. Das ist der häufigste „es startet, aber nichts geht“-Zustand — und er ist kein Bug, sondern eine leere Schlüsselquelle.

Schlüssel schichten: Umgebungsvariablen, auth.json, einmaliges Überschreiben

Die offizielle Auflösungsreihenfolge: Kommandozeile --api-key → ~/.pi/agent/auth.json → Prozessumgebung → Schlüssel eines eigenen Anbieters in models.json. Interaktiv schreibt /login OAuth oder API-Key nach auth.json (Dateirechte 0600). auth.json schlägt Umgebungsvariablen und eignet sich für „diese Maschine nutzt dauerhaft diesen Schlüssel“; Umgebungsvariablen passen zu CI und Einzelexperimenten. setRuntimeApiKey im SDK überschreibt nur im Prozess, schreibt nicht auf die Platte und eignet sich für Tests sowie Multi-Tenant-Hosts.

Diese Reihenfolge ist der eigentliche Installationsvertrag. Wer sie ignoriert, wundert sich, warum CI einen anderen Anbieter sieht als das Laptop. Ein häufiger Fehler: auf dem Entwicklerrechner liegt eine alte auth.json, in der Pipeline exportieren Sie eine frische Umgebungsvariable — und wundern sich, warum lokal immer noch der alte Schlüssel gewinnt. Lesen Sie die Kette von oben nach unten, bevor Sie das Modell beschuldigen.

export ANTHROPIC_API_KEY=sk-ant-...
export OPENAI_API_KEY=sk-...
export GEMINI_API_KEY=...   # der Schlüsselname in auth.json ist google

pi
# interaktiv: /login wählt den Anbieter; /model oder Ctrl+L wechselt; Ctrl+S speichert den Start-Default

{
  "anthropic": { "type": "api_key", "key": "sk-ant-..." },
  "openai": { "type": "api_key", "key": "sk-..." },
  "google": { "type": "api_key", "key": "..." }
}

Das Feld key akzeptiert außerdem $ENV_VAR-Interpolation und Kommandozugriffe wie !op read 'op://…' (Cache im Prozess). Auf Remote- oder Headless-Maschinen scheitern Browser-Callbacks von OpenRouter und Ähnlichem oft; offiziell müssen Sie die finale Redirect-URL oder den Autorisierungscode zurück in die Login-Aufforderung kleben — auf einem Cloud-Mac per SSH besonders häufig. Die Anbietertabelle steht in providers.md.

Claude, GPT und Gemini anbinden

Pi hält für jeden eingebauten Anbieter einen Katalog der „werkzeugfähigen“ Modelle; konfigurierte Kataloge aktualisieren sich, pi update --models erzwingt einen Abruf. Authentifizierung ist Abo (Claude Pro/Max, ChatGPT Plus/Pro Codex, GitHub Copilot) oder API-Key. Wechsel über /model oder Ctrl+L; häufige Modelle per Ctrl+P durchlaufen; /scoped-models bestimmt die Liste.

Der Katalog ist absichtlich kein Screenshot aus einem Blog. Modell-IDs wandern, Suiten benennen sich um, ein „gpt-5.1“ von letzter Woche kann in der nächsten Woche fehlen. Deshalb gehört in Produktions-Skripte kein hart kodierter Snapshot, sondern ein Lookup plus Fallback auf den Anbieterpräfix. Dasselbe gilt für Teams, die intern noch „den Claude von März“ sagen: Sagen Sie den Provider, nicht den Marketingnamen.

pi --list-models claude
pi --list-models gpt
pi --list-models gemini

pi --provider anthropic --thinking high "Mach die Schleifen in src/ zu testbaren Funktionen"
pi --model openai/gpt-4o -p "Fasse die Einstiegsmodule dieses Repos in drei Sätzen zusammen"
pi --provider google -p "Nur lesen: liste ungedeckte Testdateien"

# Wechsel in der Sitzung, ohne Neuinstallation
# /model   oder Ctrl+L
# Ctrl+P   durchläuft die scoped Liste

Modell-IDs ändern sich mit dem Katalog. Offizielle Beispiele zeigten Schreibweisen wie claude-opus-4-5, claude-sonnet-4-5, gpt-4o, gpt-5.1. In der Praxis gelten pi --list-models und getAvailable() im SDK; Snapshot-IDs aus Blogposts gehören nicht ins Produktionsskript. Eigene Gateways (Ollama, vLLM, Firmenproxy) laufen über ~/.pi/agent/models.json, sofern die Gegenseite eine OpenAI-, Anthropic- oder Google-API spricht. OAuth oder proprietary Protokolle gehören in eine Extension, nicht in eine CLI-Patcherei.

Wenn Sie wirklich „selbst HTTP schreiben, selbst JSON parsen“ wollen, sind Sie auf der Function-Calling-Schicht, nicht auf der Harness-Schicht. Vergleichen Sie Function Calling und JSON-API sowie GPT-5.6-API-Tutorial: jene Texte schlagen direkt beim Anbieter an; dieser Text lässt Pi die Werkzeugschleife führen und nur das Backend tauschen.

TypeScript-Projekt in der Praxis

Die CLI löst „ein Mensch steuert im Terminal“; das SDK löst „ein Skript im Repo steuert denselben Kreis“. Das SDK liegt im selben npm-Paket, Sie installieren nichts Zweites. Die minimale Schleife: lokale Abhängigkeit → drei Schlüssel nur in die Umgebung → ModelRuntime wählt das Modell → createAgentSession schickt eine Read-only-Aufgabe → dispose().

Schreiben Sie diese Schleife nicht „irgendwann später“. Solange der Agent nur im TUI lebt, bleibt er ein persönliches Werkzeug. Sobald scripts/pi-review.ts im Repo liegt, wird er Teil der Lieferkette: Review-Whitelist, Fehlertext, Exit-Code. Genau deshalb gehören Werkzeuge in den Code, nicht in die Gewohnheit des letzten Operators. Ein Read-only-Review, der in CI denselben Prompt fährt wie lokal, ist mehr wert als ein cleverer Chat, den niemand reproduzieren kann.

npm init -y
npm install @earendil-works/pi-coding-agent
# in package.json "type": "module" setzen

import {
  createAgentSession,
  ModelRuntime,
  SessionManager,
} from "@earendil-works/pi-coding-agent";

const runtime = await ModelRuntime.create();

if (process.env.ANTHROPIC_API_KEY) {
  await runtime.setRuntimeApiKey("anthropic", process.env.ANTHROPIC_API_KEY);
}
if (process.env.OPENAI_API_KEY) {
  await runtime.setRuntimeApiKey("openai", process.env.OPENAI_API_KEY);
}
if (process.env.GEMINI_API_KEY) {
  await runtime.setRuntimeApiKey("google", process.env.GEMINI_API_KEY);
}

const preferred =
  runtime.getModel("anthropic", "claude-opus-4-5") ??
  runtime.getModel("openai", "gpt-4o") ??
  (await runtime.getAvailable())[0];

if (!preferred) {
  throw new Error("Kein Modell verfügbar: zuerst einen der drei Schlüssel exportieren oder pi --list-models ausführen");
}

const { session } = await createAgentSession({
  model: preferred,
  thinkingLevel: "low",
  tools: ["read", "bash"],
  sessionManager: SessionManager.inMemory(),
  modelRuntime: runtime,
});

try {
  session.subscribe((event) => {
    if (
      event.type === "message_update" &&
      event.assistantMessageEvent.type === "text_delta"
    ) {
      process.stdout.write(event.assistantMessageEvent.delta);
    }
  });
  await session.prompt(
    "Nur lesen: liste die TypeScript-Einstiegsdateien im aktuellen Verzeichnis und nenne die Stelle, der Tests am ehesten fehlen. Keine Dateien ändern."
  );
} finally {
  session.dispose();
}

Der Ausschnitt begrenzt die Werkzeuge bewusst auf read + bash; die Sitzung liegt im Speicher, nicht auf der Platte. Ein Review-Skript in CI soll standardmäßig weder write noch edit besitzen. Für persistente Sitzungen nutzen Sie SessionManager.create(process.cwd()). Wollen Sie denselben langfristigen Schlüssel wie die CLI, rufen Sie setRuntimeApiKey nicht auf und lassen das Runtime ~/.pi/agent/auth.json lesen. Bei eigenem Auth-Pfad zeigen authPath / modelsPath auf das Verzeichnis der Anwendung, damit mehrere Dienste sich nicht dieselbe Home-Datei streitig machen. Ereignisse, Steuerung (steer) und Folgefragen (followUp) stehen in sdk.md.

AGENTS.md: Repo-Regeln für alle Modelle

Beim Start fügt Pi ~/.pi/agent/AGENTS.md sowie AGENTS.md (oder CLAUDE.md) aus Eltern- und aktuellem Verzeichnis zusammen. Existiert auf einer Ebene AGENTS.override.md, lädt diese Ebene nur die Override-Datei. Das ist der Anker für „Modell wechseln, Regeln behalten“: Claude, GPT und Gemini lesen dieselben Einstiege, Testbefehle und roten Linien. System-Prompts ersetzen Sie mit .pi/SYSTEM.md, ergänzen mit APPEND_SYSTEM.md.

# Regeln dieses Repos für Pi
- Paketmanager: npm. Nicht eigenmächtig auf pnpm umstellen.
- Checks: npm test && npm run lint
- Rote Linie: .env, auth.json, *.pem nicht committen
- Standard nur lesen; write/edit nur wenn der Nutzer ausdrücklich „Dateien ändern“ sagt

Headless-CI zeigt keinen Projekt-Trust-Dialog. Ohne gespeicherte Trust-Entscheidung folgt der Nicht-Interaktiv-Modus dem globalen defaultProjectTrust: ask (Standard) und never ignorieren projektweite .pi/-Ressourcen, nur always vertraut. Einmaliges Überschreiben: --approve / --no-approve. Bevor Sie Pi auf einen selbst gehosteten Runner schieben, gehört die Trust-Politik ins Maschinenimage — erst dann das Modell. Schichtung von GitHub Actions und Cloud-Mac-Runnern: GitHub Actions macOS selbstgehosteter Runner und Cloud-Mac.

Szenarien richtig wählen

Die echte Frage ist nicht „soll ich Pi installieren?“, sondern die erste Einschränkung: interaktiv Code ändern, den Agent als Skript schreiben — oder nur die Out-of-the-Box-Erfahrung einer offiziellen CLI.

Schreiben Sie die Einschränkung vor dem ersten npm install auf. Teams, die das überspringen, installieren Pi „zum Ausprobieren“, merken nach drei Tagen, dass niemand eine zweite Rechnung hat, und erklären das Harness für nutzlos. Das Harness ist nicht nutzlos. Es war die falsche erste Einschränkung. Umgekehrt: Wer nachts Reviews braucht und tagsüber Modelle tauscht, spart sich die Suche nach der nächsten IDE — sobald die erste pi -p-Zeile reproduzierbar ist.

Warum der Cloud-Mac die Ausführungsschicht des Agenten ist, folgt aus derselben Trennung: Modelle können Sie tauschen, bash und Dateiwerkzeuge bleiben an der Maschine, die den Prozess trägt. Dieser Text ergänzt die Knotenschicht: npm, Schlüssel, Modellwechsel und TypeScript-Skripte. Wer CI und Signierung auf demselben Host halten muss, landet früher oder später bei einem selbst gehosteten macOS-Runner — nicht bei einer weiteren Editor-Erweiterung.

Empfohlene Kombinationen

Werkzeuge dürfen sich stapeln. Pi löst „Coding-Harness mit austauschbarem Modell“. Es schenkt Ihnen weder einen Mac, der nie zuklappt, noch bezahlt es drei Anbieterrechnungen.

• Persönlicher Alltag: globale pi + ANTHROPIC_API_KEY als Default + zwei weitere Schlüssel in Reserve + Repo-AGENTS.md. Im TUI wechselt Ctrl+L das Modell, die Regeln bleiben.
• TypeScript-Repo: globale CLI für Menschen, SDK zusätzlich in devDependencies für Skripte. Reviews mit Read-only-Werkzeugen; Dateiänderungen über einen eigenen, manuell bestätigten Befehl.
• CI: pi -p oder SDK-Skript + GitHub-Actions-Secrets + selbst gehosteter macOS-Runner. Trust-Politik mit --approve festschreiben, Schlüssel nicht in Logs drucken.
• Multi-Anbieter-Gateway: OpenRouter / Cloudflare AI Gateway, ein Schlüssel zu mehreren Modellen; weiter mit /model von Pi wechseln. Für Teams, die keine drei Originalschlüssel auf jeder Maschine verstreuen wollen.
• Minimale Validierung: nur CLI, nur ein Schlüssel, pi -p "Liste die ts-Dateien im aktuellen Verzeichnis". Vier Schritte (Installation → Credentials → eine Aufgabe → reproduzierbar), dann zweites Modell und SDK.

Ein Multi-Agenten-Kursraum oder ein IM-Klon ist nicht PIs Heimatspiel: dort braucht es Orchestrierung und Gateway, siehe OpenMAIC und die Ära der Multi-Agenten-Kollaboration. Pi passt zu „dieselbe Lese-Ändere-Führe-aus-Schleife, Backend tauschen, weiterarbeiten“.

Häufige Irrtümer

• Pi als kostenlosen Claude-Code-Klon lesen. Sub-Agent und Plan Mode fehlen absichtlich. Fehlende Funktionen kommen über Extension oder Package — nicht über die nächste IDE, weil „der Kern zu dünn“ wirkt.
• Drei Schlüssel in dieselbe dotenv, die ins Git wandert. Entwicklerrechner: Shell-Profil oder 1Password; CI: Secrets; geteilte Maschinen: auth.json mit 0600. Der Runtime-Key des SDK liegt nicht auf der Platte und ersetzt keine Maschinen-Credentials.
• Modell-IDs aus Blogposts fest in Produktion schreiben. Der Katalog aktualisiert sich. Skripte nutzen getAvailable() oder --list-models und fallen auf stabile Anbieterpräfixe zurück.
• In CI dem Agenten standardmäßig write/edit geben. Review und Inspektion mit Read-only-Whitelist; Dateiänderungen hinter einer menschlichen Sperre.
• Im Headless-Modus einen Trust-Dialog erwarten. Zuerst defaultProjectTrust oder --approve, sonst laden projektweite Skills gar nicht.
• Lange SDK-Aufgaben auf einem Laptop, der in den Ruhezustand geht. Der Sitzungsbaum kann wiederherstellen, Seiteneffekte eines mittendrin unterbrochenen bash rollen nicht zurück. Langläufer auf Dauerknoten.

Implementierungsschritte

1. Unverhandelbares klären: nur interaktiv, nur Skript oder beides; müssen in der ersten Woche drei Modelle gleichzeitig hängen; darf CI auf die Platte schreiben.
2. CLI installieren und leerlaufen: npm install -g --ignore-scripts @earendil-works/pi-coding-agent, pi --version, PATH prüfen.
3. Nur einen Schlüssel anbinden: export oder /login, pi -p "Liste das aktuelle Verzeichnis". Abnahme ist „reproduzierbar“, nicht „längere Antwort“.
4. Zweiten und dritten Anbieter: OPENAI_API_KEY / GEMINI_API_KEY ergänzen, denselben Prompt per /model oder --provider fahren, Regeln aus AGENTS.md prüfen — nicht aus der Modelllaune.
5. SDK ins Repo: Projektabhängigkeit + ein Read-only-scripts/pi-review.ts. Werkzeug-Whitelist fest im Code.
6. Ausführungsumgebung wählen: lokal zum Lernen; CI und Langläufer auf dauerhaften Cloud-Mac oder selbst gehosteten Runner, Logs maskieren, Schlüssel nicht ins Artefakt.
7. Erst dann Extensions und Observability: Plan Mode / MCP / Rechte-Gates als Package nachladen. Zuerst Verbrauch, Rückfall und manuelle Übernahme messen, dann Fähigkeiten stapeln.

FAQ

Wie hängen Pi Coding Agent und Claude Code zusammen?

Claude Code ist Anthropics offizieller Coding-Workflow: Modell und Einstieg sind fest verdrahtet. Pi ist ein Drittanbieter-Minimales Harness. Es kann Anthropic-Schlüssel oder ein Claude-Abo nutzen und gleichzeitig OpenAI und Gemini anbinden. Es ersetzt nicht die „tiefe offizielle Integration“. Es ersetzt „Modellwechsel heißt Werkzeugwechsel“.

Müssen Claude, GPT und Gemini gleichzeitig konfiguriert sein?

Nein. Ein Schlüssel reicht für die Installationsabnahme. Der zweite Schlüssel bedeutet: dieselbe AGENTS.md und dieselbe Werkzeug-Whitelist, Backend je Aufgabe. Ohne zweite Rechnung vergrößern Sie die Betriebsfläche nicht nur wegen „Multi-Modell“.

Kollidieren globale npm-Installation und das SDK im Projekt?

Sie streiten sich nicht um denselben Befehl, die Versionen können aber driften. Konvention: Menschen nutzen die globale CLI, Skripte pinnen die Version in der Projekt-package.json. Lesen beide ~/.pi/agent, darf das Skript den langfristigen Maschinenschlüssel nicht mit einem Runtime-Key überschreiben.

Warum heißt die Gemini-Umgebungsvariable nicht GOOGLE_API_KEY?

Die offizielle Tabelle schreibt den Gemini-API-Key als GEMINI_API_KEY, der Schlüssel in auth.json heißt trotzdem google. Vertex läuft über ADC plus Projekt-/Regionsvariablen — das ist nicht derselbe Weg wie der AI-Studio-Gemini-Schlüssel. Es gilt providers.md, nicht das Bauchgefühl zum Schlüsselnamen.

Läuft die Installation unter Windows / auf einem Headless-Cloud-Mac?

Ja. Das globale npm-Paket ist plattformübergreifend; die Website bietet zusätzlich install.sh und einen PowerShell-Installer. Headless-Maschinen nutzen pi -p, RPC oder SDK, nicht das TUI. OAuth à la OpenRouter verlangt per SSH das Zurückkleben des Callbacks. Auf dem Cloud-Mac zuerst Node-Version, PATH und Rechte von auth.json festziehen.

Warum noch ein Cloud-Mac, wenn npm lokal reicht?

Lokal reicht zum Lernen der Befehle. Es reicht nicht für Nacht-Reviews, lange Fixes nach dem Zuklappen und CI, die dieselbe Umgebung wie Xcode und Signierung braucht. Pi entkoppelt das Modell; bash und Dateiwerkzeuge bleiben an der Maschine, die den Prozess gerade ausführt.

Fazit

Die Installationsanleitung von Pi Coding Agent sieht aus wie npm, Umgebungsvariablen und drei Modell-IDs. Was Sie wirklich landen müssen, ist eine Schichttrennung: Harness und Modell getrennt, Schlüssel und Repository getrennt, interaktiver Einstieg und Skript-Einstieg getrennt. Was im September 2026 trägt: globale CLI für Menschen, SDK für das Repo, AGENTS.md für alle Backends, Dauerknoten für Langläufer.

Die asymmetrische Schlussfolgerung bleibt: Die Grenze liegt nicht darin, ob Claude, GPT oder Gemini stärker ist, sondern ob Sie das Modell als austauschbares Backend behandeln können. Zuerst eine pi -p mit einem Schlüssel, dann zweites Modell und TypeScript-Skript; sobald die Ausführungsebene zählt, den Prozess vom schlafenden Laptop auf einen Cloud-Mac legen. Weiterentwickeln müssen Sie Einstieg, Credentials und Knoten — nicht den nächsten IDE-Agenten.