TL;DR: Pi draaiend krijgen in 5 minuten

Pi is een minimale, MIT-gelicentieerde AI-coding-agent-harness van Earendil die in je terminal leeft. Het komt met vier tools — read, write, edit, bash —, praat met 15+ modelproviders, slaat elk gesprek op als een vertakkende sessieboom en wordt uitgebreid via extensions, skills, prompt-templates en packages in plaats van een opgeblazen featurelijst. Draaien op een goedkope Netcup VPS maakt er een always-on agent van waar je vanaf elke machine met SSH op kunt inloggen.

Belangrijkste punten over Pi:

• Minimale kern, maximale controle — vier ingebouwde tools, al het andere is opt-in
• 15+ providers, honderden modellen — Anthropic, OpenAI, Google, Azure, Bedrock, Mistral, Groq, plus lokale llama.cpp- en Ollama-endpoints
• Boomgestructureerde sessies — elk gesprek vertakken, forken, klonen, comprimeren en exporteren
• Headless-modi — --print, --mode json en --mode rpc maken Pi scriptbaar vanuit cron en CI
• Open source — MIT-licentie, te installeren met een oneliner, npm of Nix
• Draait prima op een kleine VPS — het zware werk doet het model op afstand, dus 4 vCores en 8 GB RAM zijn ruim voldoende

Pi op een verse Netcup VPS installeren in vier commando's:

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

Voer daarna /login uit in de TUI, kies je provider en ga aan de slag.

Aanbevolen server: Netcup VPS 1000 G12.5 — 4 vCore, 8 GB ECC-RAM, 128 GB SSD, 2,5 Gbit/s met traffic-flatrate, voor EUR 12,18/maand (excl. btw).

Gebruik een van deze kortingscodes voor 1 maand gratis:

6877nc17911959135
6877nc17911959133
6877nc17911959132

Inleiding

De meeste AI-coding-agents komen met een wereldbeeld dat al geïnstalleerd is. Ze bepalen welke tools er bestaan, wanneer er om toestemming wordt gevraagd, hoe de terminal eruitziet en waar je gespreksgeschiedenis belandt. Dat werkt tot je workflow niet meer past bij die van de leverancier — en dan vecht je tegen je gereedschap in plaats van het te gebruiken.

Pi neemt het tegenovergestelde standpunt in. De slogan zegt het onomwonden: "There are many agent harnesses but this one is yours." Pi is een harness, geen product: een kleine, controleerbare kern die de agent-loop, modelverzoeken, tool-uitvoering en sessieopslag afhandelt, terwijl elk opiniërend gedrag is uitbesteed aan extensions die je zelf laadt.

Precies dat ontwerp maakt Pi een ongewoon goede kandidaat voor zelf hosten op een VPS. De agent zelf is lichtgewicht — de dure inferentie draait op de hardware van je modelprovider, niet op die van jou. Wat je werkelijk van een server nodig hebt, is uptime, een stabiel IP, snelle schijf voor sessiebestanden en repositories, en genoeg RAM om builds en testsuites naast de agent te draaien. Een Netcup VPS levert exact dat voor de prijs van een paar koffies per maand — en met de kortingscodes hieronder kan de eerste maand gratis zijn.

Deze gids behandelt wat Pi is, hoe de architectuur werkt, hoe je het dagelijks gebruikt, een volledige stap-voor-stap-deployment op Netcup, en welke goedkope Netcup-server bij welk soort Pi-workload past.

Wat is Pi?

Pi is een uitbreidbare AI-agent die vanuit je terminal werkt. Hij kan bestanden inspecteren, commando's uitvoeren, content bewerken en meerstaps-taken afwerken — het gebruikelijke agent-repertoire — maar de weg ernaartoe verschilt bewust van de concurrentie.

Pi wordt gebouwd door Earendil Inc. en uitgebracht onder de MIT-licentie. Het is geschreven in TypeScript, gedistribueerd als @earendil-works/pi-coding-agent op npm, en is inmiddels een van de meest ge-starde agent-projecten op GitHub, met ruim meer dan een miljoen npm-downloads per week. De tweede slogan — "Adapt Pi to your workflows, not the other way around" — is de hele productthese.

Primitieven boven features

De standaard Pi-agent komt met vier tools: read, write, edit en bash. Meer niet. Er is geen ingebouwd sub-agent-systeem, geen plan-modus, geen toestemmingsdialoog, geen in de kern ingebakken websearch-tool.

Dat is geen omissie. Die mogelijkheden bestaan — als optionele extensions. Sub-agents, plan-modus en permission gates zijn allemaal dingen die je installeert als je ze wilt, en weglaat als dat niet zo is. Het resultaat is een kern die klein genoeg blijft om te lezen, te debuggen en te vertrouwen, en een contextvenster dat niet vooraf is volgeladen met tooldefinities die je nooit gebruikt.

Kernmogelijkheden

Modeltoegang via veel providers Pi ondersteunt 15+ AI-providers en honderden modellen out of the box: Anthropic, OpenAI, Google, Azure, Amazon Bedrock, Mistral, Groq en meer. Wisselen met /model, doorlopen met Ctrl+P, standaard opslaan met Ctrl+S. Prijzen, contextlimieten en capaciteiten staan direct in de selector.

Lokale en eigen endpoints Pi integreert rechtstreeks met de llama.cpp-router voor GGUF-bestanden via het commando /llama. Ollama, LM Studio, vLLM en elk OpenAI-compatibel endpoint voeg je toe via een regel in models.json. Op een grotere Netcup-server betekent dat: je kunt modellen lokaal draaien en inferentie volledig op eigen hardware houden.

Boomgestructureerde sessies Elk gesprek is een JSONL-bestand op schijf waarin elke entry een ID en een parent heeft. Elk pad door die boom is een branch. Je kunt verdergaan vanaf een eerder bericht en zo een nieuwe branch in hetzelfde bestand maken, geselecteerde geschiedenis forken naar een nieuwe sessie, of de actieve branch klonen — en er gaat nooit iets verloren.

Context engineering Pi stelt zijn system prompt samen uit basisinstructies plus gevonden contextbestanden: AGENTS.md, CLAUDE.md, SYSTEM.md voor een volledige vervanging van de system prompt, en APPEND_SYSTEM.md voor toevoegingen. Compaction voegt een samenvattingsentry in die oudere berichten vervangt in volgende verzoeken, terwijl de originele entries intact blijven.

Realtime bijsturen Pi onderscheidt steering-berichten (die na de huidige beurt binnenkomen) van follow-up-berichten (die binnenkomen zodra al het openstaande werk klaar is). Je kunt een draaiende agent omleiden zonder hem af te schieten.

Vier interfaces Interactieve TUI, --print voor scriptbare tekstuitvoer, --mode json voor een JSONL-eventstream en --mode rpc voor programmatische aansturing — plus een TypeScript-SDK om Pi in je eigen applicatie in te bedden.

Extensions, skills, prompts, themes Extensions zijn TypeScript-modules die commando's, tools, event-hooks, modelproviders en MCP-servers registreren. Skills zijn mappen met een SKILL.md die op aanvraag laden. Prompt-templates en themes maken het aanpasoppervlak compleet. Alle vier kun je bundelen en delen als packages.

Wat Pi bewust niet doet

Pi vraagt niet om goedkeuring voor elke tool-aanroep en levert geen ingebouwde sandbox. Het draait met de volledige rechten van het gebruikersaccount dat het startte. De documentatie is daar bot over: "Safety comes from limiting the files, credentials, processes, and network services Pi can access."

Precies daarom is een dedicated VPS de juiste thuisbasis voor Pi. In plaats van een niet-gesandboxte agent op je laptop los te laten — met je SSH-sleutels, je wachtwoordmanager, je persoonlijke bestanden en je productie-credentials allemaal één bash-aanroep verderop — geef je hem een wegwerpserver die alleen de repositories en kortlevende tokens bevat die de taak werkelijk nodig heeft. Een Netcup VPS voor EUR 12,18/maand is een goedkope, herbouwbare blast radius.

Hoe je Pi gebruikt

De terminal-UI

Pi draait standaard fullscreen en verdeelt zich in drie gebieden: een transcript van prompts en antwoorden, een editor om invoer op te stellen, en een footer met sessiemetadata, contextgebruik en opgebouwde kosten. De randkleur van de editor weerspiegelt het huidige thinking-niveau, dus je weet altijd hoe hard het model moet werken.

Slash-commando's

Typ / om het commandopalet te doorzoeken. Die je constant gebruikt:

Sneltoetsen om te onthouden

• Enter verstuurt, Shift+Enter voegt een nieuwe regel toe
• Alt+Enter zet een follow-up in de wachtrij na de huidige taak
• Escape stopt de lopende taak
• Ctrl+G opent je externe editor voor lange prompts
• Ctrl+O klapt tool-uitvoer uit of in
• Ctrl+T schakelt thinking-blokken
• Ctrl+X kopieert het laatste antwoord
• Ctrl+L opent de modelselector

Bestanden refereren en shell-commando's draaien

Typ @ om bestanden te zoeken en toe te voegen, of gebruik Tab voor padaanvulling. In terminals die dat ondersteunen kun je afbeeldingen direct in de editor plakken of slepen.

Zet een ! vooraan een regel om een shell-commando uit te voeren en de uitvoer in het gesprek op te nemen. Met !! draait het commando zonder het resultaat met het model te delen — handig om midden in een sessie even privé iets te controleren.

Configuratie-indeling

Pi gebruikt een tweelaags configuratiesysteem. De agent-map staat standaard op ~/.pi/agent en is te verplaatsen met PI_CODING_AGENT_DIR:

~/.pi/agent/
  settings.json        # gebruikersvoorkeuren en resourcepaden
  keybindings.json     # eigen sneltoetsen
  mcp.json             # projectoverstijgend beschikbare MCP-servers
  models.json          # eigen endpoints en modeldefinities
  auth.json            # opgeslagen API-keys en OAuth-credentials
  AGENTS.md            # gebruikersbrede instructies
  SYSTEM.md            # volledige vervanging van de system prompt
  APPEND_SYSTEM.md     # aanvullende instructies
  extensions/ skills/ prompts/ themes/

Een projectmap op .pi/ spiegelt deze structuur voor overrides per repository, en laadt pas nadat je project trust hebt gegeven. Het vertrouwde projectbestand heeft voorrang boven het overeenkomstige bestand in de agent-map.

Skills

Een skill is een map met een SKILL.md met YAML-frontmatter — name, description, license, compatibility, disable-model-invocation — plus alle scripts, referenties en assets die hij nodig heeft.

Bij het opstarten scant Pi de geconfigureerde skill-mappen en voegt naam, beschrijving en pad van elke skill toe aan de system prompt. De volledige instructies laden pas wanneer de skill daadwerkelijk nodig is, waardoor gedetailleerde richtlijnen buiten de context blijven tot het ertoe doet. Skills worden gevonden in ~/.agents/skills/ en .agents/skills/, recursief doorzocht, stoppend bij repository-wortels.

De leidende regel uit de docs: "Use a skill when a workflow needs more context than a prompt template but does not need a new executable integration point."

Extensions

Extensions zijn TypeScript- of JavaScript-modules in ~/.pi/agent/extensions/. Een minimale ziet er zo uit:

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

Laad er tijdens ontwikkeling direct een met pi --extension ./hello.ts. Pi gebruikt jiti om TypeScript zonder buildstap te compileren.

Extensions registreren via pi.registerCommand(), pi.registerTool(), pi.registerProvider(), pi.registerMcpServer() en pi.on() voor lifecycle-events zoals session_start, before_agent_start, tool_call en message_end. Langlevende resources start je vanuit session_start, niet vanuit de factory-functie, omdat sommige aanroepen de sessie-initialisatie overslaan.

Extensions draaien binnen het Pi-proces met volledige OS-rechten. Laad ze alleen uit bronnen die je vertrouwt.

Packages

Een package bundelt extensions, skills, prompts en themes tot één distribueerbare eenheid — een gewone map of 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

Testen zonder installeren kan met pi -e npm:@example/pi-tools. Uitgevers voegen het keyword pi-package toe aan de npm-metadata zodat het package vindbaar is in de gallery.

Headless-modi voor automatisering

Hier betaalt een zelfgehoste Pi op een VPS zich echt terug. De niet-interactieve modi maken van Pi een scriptbaar component:

# Print-modus: prompts draaien, finale tekst naar stdout, afsluiten
pi --print "Summarise the open TODOs in this repo"

# JSON-modus: een JSONL-eventstream uitsturen om te parsen
pi --mode json "Run the test suite and report failures"

# RPC-modus: JSONL-commando's van stdin lezen, antwoorden terugstreamen
pi --mode rpc

Handige flags voor onbewaakte runs:

Combineer --print met -t en --approve in een cronjob en je Netcup VPS wordt een autonome onderhoudswerker: nachtelijke dependency-audits, changelog-concepten, logtriage, geplande refactors.

Hoe de agent-loop werkelijk werkt

De loop begrijpen helpt bij debuggen en tunen:

1. Invoer — een verstuurd bericht voegt zich bij de actieve gespreksbranch
2. Request opbouwen — Pi stelt de system prompt, de actieve branch, beschikbare tools en modelinstellingen samen
3. Antwoord — de provider streamt tekst en tool-aanroepen terug
4. Tool-uitvoering — Pi registreert het antwoord, voert elke tool-aanroep uit en registreert de resultaten
5. Loop-besturing — staat er nog werk open, dan volgt een nieuwe beurt; anders is de run klaar

Tools en extensions draaien binnen het Pi-proces, met de besturingssysteemrechten van dat proces. Er is geen aparte sandboxlaag tenzij je er een maakt — precies wat de containerisatiestap in de quick start hieronder doet.

Quick start: Pi deployen op een Netcup VPS

Stap 1: Bestel je Netcup-server

Ga naar netcup.com, kies de VPS 1000 G12.5 (4 vCore, 8 GB ECC-RAM, 128 GB SSD, 2,5 Gbit/s) en verzilver bij het afrekenen een kortingscode:

6877nc17911959130
6877nc17913304870
6877nc17912005430

Kies een datacenter dicht bij je in de buurt — Neurenberg, Wenen, Amsterdam, Manassas of Singapore — want TUI-latency over SSH is wat je elke dag voelt. Selecteer een recente Ubuntu LTS of Debian image. Provisioning duurt doorgaans een paar minuten, waarna je gegevens in het netcup Customer Control Panel verschijnen.

Heb je liever EUR 5 korting op elke bestelling dan een gratis maand, gebruik dan 36nc17718015540.

Stap 2: Eerste login en serverhardening

Pi draait met de volledige rechten van je account, dus hard de machine voordat je het installeert:

ssh root@your-server-ip

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

# Kopieer je SSH-sleutel naar de nieuwe gebruiker
rsync --archive --chown=pi:pi ~/.ssh /home/pi/

Schakel wachtwoordlogin en root-SSH uit in /etc/ssh/sshd_config:

PermitRootLogin no
PasswordAuthentication no

Herstart daarna SSH en zet de firewall aan:

systemctl restart ssh
ufw allow OpenSSH
ufw enable

Log vanaf hier in als de gebruiker pi. Netcups out-of-band remote console in het control panel is je vangnet mocht je jezelf ooit buitensluiten.

Stap 3: Node.js en afhankelijkheden installeren

Pi vereist Node.js 22.19 of nieuwer. Installeer dat plus de tools die Pi's bash-tool verwacht:

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   # moet v22.19.0 of hoger melden

Stap 4: Pi installeren

Kies een van drie installatieroutes.

Installatiescript (aanbevolen):

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

Verifieer de installatie:

pi --version

Stap 5: Authenticeren en een model kiezen

Ga naar een werkmap en start de TUI:

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

Voer in Pi /login uit, kies je provider en volg de stappen. Credentials worden opgeslagen in ~/.pi/agent/auth.json.

Voor headless- en CI-gebruik sla je opgeslagen credentials helemaal over en exporteer je in plaats daarvan de provider-omgevingsvariabele — Pi lost credentials op in deze volgorde: --api-key-flag, dan auth.json, dan het veld apiKey in models.json, dan omgevingsvariabelen of aanwezige cloud-credentials:

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

Draai daarna /model om modellen te bekijken die gefilterd zijn op werkende authenticatie. Ctrl+S slaat je standaard op; Ctrl+P loopt erdoorheen.

Stap 6: tmux instellen zodat Pi verbroken verbindingen overleeft

Dit is de waardevolste stap voor een remote server. Zonder tmux doodt een weggevallen SSH-verbinding je agent midden in een taak.

tmux heeft ook extended keys nodig, anders meldt het Shift+Enter, Ctrl+Enter en gewone Enter als dezelfde toets. Voeg toe aan ~/.tmux.conf (tmux 3.5+):

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

Op tmux 3.2–3.4 gebruik je alleen de eerste regel. Herstart de server en start een benoemde sessie:

tmux kill-server
tmux new -s pi

Controleer dat Shift+Enter regelafbrekingen invoegt, Enter verstuurt en Alt+Enter follow-ups in de wachtrij zet. Koppel nu los met Ctrl+B D, klap je laptop dicht en verbind later vanaf elke plek opnieuw:

tmux attach -t pi

Stap 7: Projectcontext opzetten

Pi leest contextbestanden om je conventies te begrijpen. Maak een gebruikersbrede ~/.pi/agent/AGENTS.md voor zaken die altijd gelden, en een AGENTS.md per repository voor projectspecifieke zaken:

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

Start Pi en refereer bestanden met @:

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

Stap 8: Containeriseren voor een echte sandbox

Omdat Pi geen ingebouwd rechtensysteem heeft, is containerisatie de sterkste praktische isolatie. Op een VPS is dat goedkope verzekering: de container beschermt hostresources die je niet expliciet hebt blootgesteld.

Installeer Docker en maak Dockerfile.pi:

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"]

Bouwen en draaien:

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

De mount $PWD:/workspace stelt alleen het huidige project bloot. Het benoemde volume pi-agent-home bewaart containerlokale instellingen, credentials en sessies tussen runs. Controleer de grens vanuit Pi met !pwd — dat hoort /workspace te printen. Mount je host-~/.pi/agent niet, tenzij je specifiek de bestaande configuratie nodig hebt.

Stap 9: Een geplande agent-job toevoegen

Met Pi op een always-on Netcup VPS kun je autonoom werk inplannen. Voeg een cron-regel toe:

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

Let op de allowlist -t read,bash: de job mag inspecteren en commando's draaien, maar geen willekeurige bestanden schrijven of bewerken. Beperk tools tot het minimum dat elke job nodig heeft.

Stap 10: Optioneel — modellen lokaal draaien

Op een grotere Netcup-server kun je inferentie op eigen hardware houden. Pi ondersteunt de llama.cpp-router native via /llama. Voor Ollama, LM Studio of vLLM voeg je ze toe aan ~/.pi/agent/models.json:

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

De dummy-API-key volstaat voor Pi; Ollama negeert hem. Gebruik voor geauthenticeerde endpoints $NAME-interpolatie uit omgevingsvariabelen in plaats van letterlijke waarden.

Stap 11: Back-up je sessies

Sessies staan in ~/.pi/agent/sessions/, geordend per werkmap. Het is gewone JSONL — eenvoudig te archiveren:

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

Combineer dit met netcup-snapshots uit het control panel voor herstelpunten van de hele server vóór riskante upgrades.

De juiste Netcup-server kiezen voor goedkope Pi-hosting

Pi's eigen resourcevoetafdruk is bescheiden — het is een Node.js-proces dat tokens streamt van een remote API. Wat je server werkelijk belast, zijn de commando's die Pi uitvoert: builds, testsuites, Docker-images, language servers en, als je lokaal gaat, modelinferentie.

Zo sluit de huidige netcup VPS G12.5-lijn aan op Pi-workloads.

VPS-vergelijking voor Pi

Alle niveaus bevatten IPv4 + IPv6, een traffic-flatrate, snapshots, DDoS-bescherming, volledige roottoegang en een out-of-band remote console. Locaties: Neurenberg, Wenen, Amsterdam, Manassas, Singapore.

Aanbevolen configuraties

VPS 1000 G12.5 — de standaardkeuze voor Pi

4 vCores, 8 GB ECC-RAM, 128 GB SSD voor EUR 12,18/maand. Dit draait Pi comfortabel met een paar repositories, ripgrep-zoekacties over grote codebases, Node- of Python-testsuites en een tmux-sessie die je wekenlang aangekoppeld laat. Gebruik je modellen van Anthropic, OpenAI of Google, dan is dit alle server die Pi nodig heeft.

Kortingscodes voor 1 maand gratis:

6877nc17911959135
6877nc17911959133
6877nc17911959132

VPS 2000 G12.5 — gecontaineriseerd en meerdere projecten

8 vCores, 16 GB ECC-RAM, 256 GB SSD voor EUR 22,62/maand. Het juiste niveau zodra je Pi in Docker-sandboxes draait, meerdere projectcontainers warm houdt, of builds draait die parallellisme echt benutten. 16 GB laat ruimte voor een database en een language server naast de agent.

Kortingscodes voor 1 maand gratis:

6878nc17911959164
6878nc17911959163
6878nc17911959162

VPS 4000 G12.5 — parallelle Pi-sessies en CI

12 vCores, 32 GB ECC-RAM, 512 GB SSD voor EUR 38,11/maand. Draai meerdere onafhankelijke Pi-sessies tegen verschillende branches, elk in een eigen container, plus een CI-runner op dezelfde machine. De 512 GB SSD slikt Docker-layercaches, node_modules-bomen en maandenlang sessie-JSONL zonder opruimen.

Kortingscodes voor 1 maand gratis:

6879nc17911959182
6879nc17911959181
6879nc17911959180

VPS 8000 G12.5 — team-harness en lokale inferentie

16 vCores, 64 GB ECC-RAM, 1 TB SSD voor EUR 56,39/maand. De top van de lijn met gedeelde cores. Genoeg RAM om middelgrote GGUF-modellen via llama.cpp of Ollama te serveren terwijl meerdere ontwikkelaars hun eigen Pi-sessies over SSH draaien, elk met een eigen agent-map.

Kortingscodes voor 1 maand gratis:

6880nc17911959200
6880nc17911959205
6880nc17911959204

Root Servers: dedicated cores voor voorspelbare agent-runs

Draait Pi op schema testsuites of compilaties, dan halen dedicated cores de variatie van gedeelde CPU eruit. Netcups Root Server G12.5-lijn gebruikt AMD EPYC 9645-cores met NVMe-opslag.

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

6874nc17911959060
6874nc17911959065
6874nc17911959064

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

6875nc17912005420
6875nc17911959085
6875nc17911959084

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

6876nc17911959103
6876nc17911959102
6876nc17911959101

Hoe je kiest

Begin met de VPS 1000 G12.5. Pi's agent-proces is klein; de server bestaat om je toolchain te draaien. Upgrade pas als je tegen een echte muur loopt:

• RAM tekort tijdens builds — stap over naar VPS 2000 G12.5
• Builds voelen wisselvallig op piekuren — stap over naar een Root Server met dedicated cores
• Meer dan twee of drie gelijktijdige Pi-containers — stap over naar VPS 4000 G12.5
• Lokale GGUF-modellen via /llama serveren — ga direct naar VPS 8000 G12.5 of RS 8000 G12.5, waar RAM de beperkende factor is

Opslag inschatten. Sessie-JSONL-bestanden zijn piepklein. Wat groeit, zijn Docker-layers, dependency-caches en gekloonde repositories. 128 GB is royaal voor een handvol projecten; mirror je grote monorepo's, ga dan een niveau hoger of voeg netcup Local Block Storage toe.

Locatie. Kies het dichtstbijzijnde datacenter. De Pi-TUI is interactief en elke toetsaanslag gaat over het netwerk — 20 ms voelt direct, 200 ms niet.

Kosten optimaliseren

1. Verzilver bij elke eerste bestelling een kortingscode. Een gratis maand op een VPS 2000 G12.5 is EUR 22,62 die je houdt.
2. Gebruik uurfacturering voor experimenten. Server opstarten, een Pi-extension testen, weer verwijderen.
3. Kies 12 maanden voor het laagste maandtarief zodra je setup is uitgekristalliseerd.
4. Klein beginnen en opschalen. Netcup maakt upgraden eenvoudig; op dag één te groot inkopen is weggegooid geld.
5. Stapel 36nc17718015549 voor EUR 5 korting op elke bestelling wanneer er voor jouw niveau geen gratis-maandcode geldt.

Overzicht kortingscodes

Meer actuele codes vind je altijd op netcup.best.

Conclusie

Pi is de agent-harness voor mensen die hun gereedschap willen begrijpen en beheersen. Een kern met vier tools, een gedocumenteerde agent-loop, sessies als leesbare JSONL-bomen, en een extension-API waarmee je precies de mogelijkheden toevoegt die je nodig hebt — sub-agents, plan-modus, permission gates — in plaats van andermans defaults te erven. Het is MIT-gelicentieerd, installeert met één commando en praat met 15+ modelproviders plus elk lokaal endpoint waar je het op richt.

Dezelfde minimalistische aanpak draagt een afweging die Pi openlijk benoemt: geen ingebouwde sandbox, geen goedkeuring per aanroep, volledige gebruikersrechten. Het op je eigen machine draaien betekent een door een LLM aangestuurd bash-tool de sleutels geven tot alles wat je bezit.

Pi zelf hosten op een Netcup VPS lost dat netjes op. Een dedicated server is een beheerste blast radius — hij bevat alleen de repositories en kortlevende credentials die een taak werkelijk vereist, je kunt er een snapshot van maken vóór iets riskants, en hem in minuten vanaf nul herbouwen als er iets misgaat. Leg Docker-containerisatie erbovenop en je hebt de isolatie die Pi bewust aan de beheerder overlaat.

De praktische voordelen stapelen zich snel op:

• Altijd aan. Start een lange refactor in tmux, klap je laptop dicht, koppel morgen vanaf je telefoon weer aan.
• Echt geïsoleerd. De agent raakt een wegwerpserver aan, niet je persoonlijke bestandssysteem, SSH-sleutels of wachtwoordmanager.
• Automatiseerbaar. --print, --mode json en --mode rpc plus cron maken van je VPS een autonome onderhoudswerker die zijn eigen tooltoegang inperkt.
• Snel en dicht bij je data. 2,5 Gbit/s met traffic-flatrate, NVMe- of SSD-opslag en vijf datacenterlocaties.
• Herstelbaar. Snapshots, een out-of-band remote console en volledige roottoegang betekenen dat geen buitensluiting definitief is.
• Privé by default. Met een lokaal llama.cpp- of Ollama-endpoint op een groter niveau verlaat je code nooit infrastructuur die jij beheert.

En het is goedkoop. Een VPS 1000 G12.5 voor EUR 12,18/maand draait Pi, je toolchain en je repositories met ruimte over — veel minder dan één maand van de meeste gehoste AI-ontwikkelplatformen, en de hele stack is van jou. Met een kortingscode kost de eerste maand niets:

6877nc17913304870
6877nc17912005430
6877nc17911959135

Pi's belofte is dat de harness van jou is. Zet hem dan ook op een server die van jou is.