TL;DR: ejecutar Pi en 5 minutos

Pi es un harness de agente de IA para programar minimalista y con licencia MIT, creado por Earendil, que vive en tu terminal. Incluye cuatro herramientas — read, write, edit, bash —, habla con más de 15 proveedores de modelos, guarda cada conversación como un árbol de sesiones ramificado y se amplía mediante extensiones, skills, plantillas de prompts y paquetes en lugar de una lista de funciones inflada. Ejecutarlo en un VPS barato de Netcup lo convierte en un agente siempre activo al que puedes conectarte por SSH desde cualquier máquina.

Puntos clave sobre Pi:

• Núcleo mínimo, control máximo — cuatro herramientas integradas, todo lo demás es opcional
• Más de 15 proveedores, cientos de modelos — Anthropic, OpenAI, Google, Azure, Bedrock, Mistral, Groq, además de endpoints locales de llama.cpp y Ollama
• Sesiones con estructura de árbol — ramifica, bifurca, clona, compacta y exporta cualquier conversación
• Modos headless — --print, --mode json y --mode rpc hacen que Pi sea scriptable desde cron y CI
• Código abierto — licencia MIT, instalable con una sola línea, npm o Nix
• Funciona de maravilla en un VPS pequeño — el trabajo pesado lo hace el modelo en remoto, así que 4 vCores y 8 GB de RAM sobran

Instala Pi en un VPS nuevo de Netcup con cuatro comandos:

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

Después ejecuta /login dentro de la TUI, elige tu proveedor y ponte a trabajar.

Servidor recomendado: Netcup VPS 1000 G12.5 — 4 vCore, 8 GB de RAM ECC, 128 GB SSD, 2,5 Gbit/s con tráfico ilimitado, por EUR 12,18/mes (sin IVA).

Usa uno de estos cupones para obtener 1 mes gratis:

6877nc17911959133
6877nc17911959132
6877nc17911959130

Introducción

La mayoría de los agentes de IA para programar llegan con una visión del mundo ya instalada. Deciden qué herramientas existen, cuándo pedir permiso, cómo se ve la terminal y dónde acaba tu historial de conversaciones. Eso funciona hasta que tu flujo de trabajo deja de coincidir con el que imaginó el fabricante, y entonces peleas contra la herramienta en lugar de usarla.

Pi adopta la postura contraria. Su eslogan lo dice sin rodeos: "There are many agent harnesses but this one is yours." Pi es un harness, no un producto: un núcleo pequeño y auditable que gestiona el bucle del agente, las peticiones al modelo, la ejecución de herramientas y el almacenamiento de sesiones, con cada comportamiento opinado desplazado a extensiones que tú decides cargar.

Ese diseño convierte a Pi en un candidato inusualmente bueno para el autoalojamiento en un VPS. El agente en sí es ligero: la inferencia cara ocurre en el hardware de tu proveedor de modelos, no en el tuyo. Lo que realmente necesitas de un servidor es disponibilidad, una IP estable, disco rápido para archivos de sesión y repositorios, y suficiente RAM para ejecutar compilaciones y suites de pruebas junto al agente. Un VPS de Netcup ofrece exactamente eso por el precio de un par de cafés al mes, y con los cupones de más abajo el primer mes puede salir gratis.

Esta guía cubre qué es Pi, cómo funciona su arquitectura, cómo usarlo en el día a día, un despliegue paso a paso completo en Netcup y qué nivel de servidor barato de Netcup encaja con cada tipo de carga de trabajo de Pi.

¿Qué es Pi?

Pi es un agente de IA extensible que funciona desde tu terminal. Puede inspeccionar archivos, ejecutar comandos, editar contenido y resolver tareas de varios pasos —el repertorio habitual de un agente—, pero el camino para llegar ahí es deliberadamente distinto al de su competencia.

Pi está desarrollado por Earendil Inc. y publicado bajo la licencia MIT. Está escrito en TypeScript, se distribuye como @earendil-works/pi-coding-agent en npm y se ha convertido en uno de los proyectos de agentes con más estrellas de GitHub, con bastante más de un millón de descargas semanales en npm. Su segundo eslogan — "Adapt Pi to your workflows, not the other way around" — resume toda la tesis del producto.

Primitivas antes que funciones

El agente Pi por defecto trae cuatro herramientas: read, write, edit y bash. Nada más. No hay sistema de subagentes integrado, ni modo de planificación, ni diálogo de permisos, ni herramienta de búsqueda web incrustada en el núcleo.

No es un descuido. Esas capacidades existen, como extensiones opcionales. Los subagentes, el modo de planificación y las puertas de permisos son cosas que instalas si las quieres y que omites si no. El resultado es un núcleo que sigue siendo lo bastante pequeño como para leerlo, depurarlo y confiar en él, y una ventana de contexto que no viene precargada con definiciones de herramientas que nunca vas a usar.

Capacidades principales

Acceso a modelos de múltiples proveedores Pi admite más de 15 proveedores de IA y cientos de modelos de serie: Anthropic, OpenAI, Google, Azure, Amazon Bedrock, Mistral, Groq y más. Cambia con /model, recorre con Ctrl+P, guarda un valor por defecto con Ctrl+S. Precios, límites de contexto y capacidades se muestran directamente en el selector.

Endpoints locales y personalizados Pi se integra directamente con el router de llama.cpp para archivos GGUF mediante el comando /llama. Ollama, LM Studio, vLLM y cualquier endpoint compatible con OpenAI se añaden con una entrada en models.json. En un servidor Netcup más grande esto significa que puedes ejecutar modelos localmente y mantener la inferencia íntegramente en tu propio hardware.

Sesiones con estructura de árbol Cada conversación es un archivo JSONL en disco donde cada entrada tiene un ID y un padre. Cualquier recorrido por ese árbol es una rama. Puedes continuar desde un mensaje anterior y crear así una nueva rama en el mismo archivo, bifurcar parte del historial hacia una sesión nueva o clonar la rama activa, y nada se destruye nunca.

Ingeniería de contexto Pi compone su prompt de sistema a partir de instrucciones base más los archivos de contexto que descubre: AGENTS.md, CLAUDE.md, SYSTEM.md para una sustitución completa del prompt de sistema y APPEND_SYSTEM.md para añadidos. La compactación inserta una entrada de resumen que reemplaza los mensajes antiguos en las peticiones posteriores, dejando intactas las entradas originales.

Dirección en tiempo real Pi distingue entre mensajes de dirección (que entran después del turno actual) y mensajes de seguimiento (que entran cuando termina todo el trabajo pendiente). Puedes redirigir a un agente en marcha sin matarlo.

Cuatro interfaces TUI interactiva, --print para salida de texto scriptable, --mode json para un flujo de eventos JSONL y --mode rpc para control programático, además de un SDK de TypeScript para integrar Pi dentro de tu propia aplicación.

Extensiones, skills, prompts y temas Las extensiones son módulos de TypeScript que registran comandos, herramientas, hooks de eventos, proveedores de modelos y servidores MCP. Las skills son directorios con un SKILL.md que se cargan bajo demanda. Las plantillas de prompts y los temas completan la superficie de personalización. Las cuatro se pueden empaquetar y compartir como paquetes.

Lo que Pi deliberadamente no hace

Pi no pide aprobación antes de cada llamada a herramienta y no incluye un sandbox integrado. Se ejecuta con todos los permisos de la cuenta de usuario que lo inició. La documentación es tajante al respecto: "Safety comes from limiting the files, credentials, processes, and network services Pi can access."

Precisamente por eso un VPS dedicado es el hogar adecuado para Pi. En lugar de apuntar un agente sin sandbox a tu portátil —con tus claves SSH, tu gestor de contraseñas, tus archivos personales y tus credenciales de producción a una llamada bash de distancia— le das un servidor desechable que contiene solo los repositorios y los tokens de corta duración que la tarea realmente necesita. Un VPS de Netcup a EUR 12,18/mes es un radio de daño barato y reconstruible.

Cómo usar Pi

La interfaz de terminal

Pi se ejecuta a pantalla completa por defecto y se divide en tres áreas: una transcripción de prompts y respuestas, un editor para redactar la entrada y un pie que muestra metadatos de sesión, uso de contexto y coste acumulado. El color del borde del editor refleja el nivel de razonamiento actual, así que siempre sabes con cuánta intensidad se le está pidiendo trabajar al modelo.

Comandos de barra

Escribe / para buscar en la paleta de comandos. Los que usarás constantemente:

Atajos que conviene memorizar

• Enter envía, Shift+Enter añade una línea nueva
• Alt+Enter encola un seguimiento para después de la tarea actual
• Escape detiene la tarea en curso
• Ctrl+G abre tu editor externo para prompts largos
• Ctrl+O expande o colapsa la salida de las herramientas
• Ctrl+T alterna los bloques de razonamiento
• Ctrl+X copia la última respuesta
• Ctrl+L abre el selector de modelos

Referenciar archivos y ejecutar comandos de shell

Escribe @ para buscar y adjuntar archivos, o usa Tab para autocompletar rutas. En las terminales que lo soportan, las imágenes se pueden pegar o arrastrar directamente al editor.

Antepón ! a una línea para ejecutar un comando de shell e incluir su salida en la conversación. Usa !! para ejecutar un comando sin compartir el resultado con el modelo, útil para consultar algo en privado a mitad de sesión.

Estructura de configuración

Pi usa un sistema de configuración de dos niveles. El directorio del agente está por defecto en ~/.pi/agent y se puede mover con PI_CODING_AGENT_DIR:

~/.pi/agent/
  settings.json        # preferencias de usuario y rutas de recursos
  keybindings.json     # atajos personalizados
  mcp.json             # servidores MCP disponibles en todos los proyectos
  models.json          # endpoints y definiciones de modelos propios
  auth.json            # claves de API y credenciales OAuth guardadas
  AGENTS.md            # instrucciones a nivel de usuario
  SYSTEM.md            # sustitución completa del prompt de sistema
  APPEND_SYSTEM.md     # instrucciones añadidas
  extensions/ skills/ prompts/ themes/

Un directorio de proyecto en .pi/ replica esta estructura para sobrescrituras por repositorio y solo se carga después de conceder confianza al proyecto. El archivo de proyecto confiable tiene prioridad sobre el archivo correspondiente del directorio del agente.

Skills

Una skill es un directorio que contiene un SKILL.md con frontmatter YAML — name, description, license, compatibility, disable-model-invocation — además de los scripts, referencias y recursos que necesite.

Al arrancar, Pi escanea los directorios de skills configurados y añade nombre, descripción y ruta de cada skill al prompt de sistema. Las instrucciones completas se cargan solo cuando la skill se necesita de verdad, lo que mantiene las guías detalladas fuera del contexto hasta que importan. Las skills se descubren en ~/.agents/skills/ y .agents/skills/, con búsqueda recursiva que se detiene en las raíces de repositorio.

La regla rectora de la documentación: "Use a skill when a workflow needs more context than a prompt template but does not need a new executable integration point."

Extensiones

Las extensiones son módulos de TypeScript o JavaScript en ~/.pi/agent/extensions/. Una mínima tiene este aspecto:

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

Durante el desarrollo, carga una directamente con pi --extension ./hello.ts. Pi usa jiti para compilar TypeScript sin paso de compilación adicional.

Las extensiones se registran mediante pi.registerCommand(), pi.registerTool(), pi.registerProvider(), pi.registerMcpServer() y pi.on() para eventos del ciclo de vida como session_start, before_agent_start, tool_call y message_end. Los recursos de larga vida deben iniciarse desde session_start, no desde la función de fábrica, porque algunas invocaciones se saltan la inicialización de sesión.

Las extensiones se ejecutan dentro del proceso de Pi con todos los permisos del sistema operativo. Cárgalas solo desde fuentes en las que confíes.

Paquetes

Un paquete agrupa extensiones, skills, prompts y temas en una unidad distribuible: un directorio normal o un paquete de npm:

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

Para probar sin instalar, usa pi -e npm:@example/pi-tools. Los publicadores añaden la palabra clave pi-package a los metadatos de npm para que el paquete sea descubrible en la galería.

Modos headless para automatización

Aquí es donde un Pi autoalojado en un VPS demuestra su valor. Los modos no interactivos convierten a Pi en un componente scriptable:

# Modo print: ejecuta los prompts, escribe el texto final en stdout y sale
pi --print "Summarise the open TODOs in this repo"

# Modo JSON: emite un flujo de eventos JSONL para parsear
pi --mode json "Run the test suite and report failures"

# Modo RPC: lee comandos JSONL de stdin y transmite respuestas por stdout
pi --mode rpc

Flags útiles para ejecuciones desatendidas:

Combina --print con -t y --approve en una tarea de cron y tu VPS de Netcup se convierte en un operario de mantenimiento autónomo: auditorías nocturnas de dependencias, borradores de changelog, triaje de logs, refactorizaciones programadas.

Cómo funciona realmente el bucle del agente

Entender el bucle ayuda a depurarlo y afinarlo:

1. Entrada — un mensaje enviado se incorpora a la rama de conversación activa
2. Construcción de la petición — Pi ensambla el prompt de sistema, la rama activa, las herramientas disponibles y los ajustes del modelo
3. Respuesta — el proveedor devuelve texto y llamadas a herramientas en streaming
4. Ejecución de herramientas — Pi registra la respuesta, ejecuta cada llamada a herramienta y registra los resultados
5. Control del bucle — si queda trabajo pendiente, se ejecuta otro turno; si no, la ejecución termina

Las herramientas y extensiones se ejecutan dentro del proceso de Pi, con los permisos del sistema operativo de ese proceso. No hay una capa de sandbox separada a menos que la crees tú, que es exactamente lo que hace el paso de contenedorización del inicio rápido de más abajo.

Guía de inicio rápido: desplegar Pi en un VPS de Netcup

Paso 1: contrata tu servidor Netcup

Entra en netcup.com, elige el VPS 1000 G12.5 (4 vCore, 8 GB de RAM ECC, 128 GB SSD, 2,5 Gbit/s) y aplica un cupón al finalizar la compra:

6877nc17913304870
6877nc17912005430
6877nc17911959135

Elige un centro de datos cercano — Núremberg, Viena, Ámsterdam, Manassas o Singapur — porque la latencia de la TUI sobre SSH es lo que notarás cada día. Selecciona una imagen reciente de Ubuntu LTS o Debian. El aprovisionamiento suele tardar unos minutos, tras los cuales tus credenciales aparecen en el Customer Control Panel de netcup.

Si prefieres EUR 5 de descuento en cualquier pedido en lugar de un mes gratis, usa 36nc17718015541.

Paso 2: primer acceso y fortificación del servidor

Pi se ejecuta con todos los permisos de tu cuenta, así que fortifica la máquina antes de instalarlo:

ssh root@your-server-ip

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

# Copia tu clave SSH al nuevo usuario
rsync --archive --chown=pi:pi ~/.ssh /home/pi/

Desactiva el acceso por contraseña y el SSH de root en /etc/ssh/sshd_config:

PermitRootLogin no
PasswordAuthentication no

Después reinicia SSH y activa el cortafuegos:

systemctl restart ssh
ufw allow OpenSSH
ufw enable

A partir de aquí, conéctate como el usuario pi. La consola remota fuera de banda de Netcup en el panel de control es tu red de seguridad si alguna vez te dejas fuera.

Paso 3: instala Node.js y dependencias

Pi requiere Node.js 22.19 o superior. Instálalo junto con las herramientas que espera la herramienta bash de Pi:

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   # debe indicar v22.19.0 o superior

Paso 4: instala Pi

Elige una de las tres vías de instalación.

Script de instalación (recomendado):

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

Verifica la instalación:

pi --version

Paso 5: autentícate y elige un modelo

Sitúate en un directorio de trabajo y lanza la TUI:

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

Dentro de Pi, ejecuta /login, elige tu proveedor y sigue las indicaciones. Las credenciales se guardan en ~/.pi/agent/auth.json.

Para uso headless y en CI, evita por completo las credenciales guardadas y exporta en su lugar la variable de entorno del proveedor: Pi resuelve las credenciales en este orden: flag --api-key, luego auth.json, luego el campo apiKey de models.json, y luego variables de entorno o credenciales de nube del propio entorno:

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

Después ejecuta /model para explorar los modelos filtrados por autenticación funcional. Ctrl+S guarda tu valor por defecto; Ctrl+P los recorre.

Paso 6: configura tmux para que Pi sobreviva a las desconexiones

Este es el paso más valioso para un servidor remoto. Sin tmux, una conexión SSH caída mata tu agente a mitad de tarea.

tmux también necesita teclas extendidas, porque de lo contrario informa Shift+Enter, Ctrl+Enter y Enter a secas como la misma tecla. Añade a ~/.tmux.conf (tmux 3.5+):

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

En tmux 3.2–3.4, usa solo la primera línea. Reinicia el servidor e inicia una sesión con nombre:

tmux kill-server
tmux new -s pi

Comprueba que Shift+Enter inserta saltos de línea, Enter envía y Alt+Enter encola seguimientos. Ahora desvincúlate con Ctrl+B D, cierra el portátil y vuelve a conectarte más tarde desde donde sea:

tmux attach -t pi

Paso 7: configura el contexto del proyecto

Pi lee archivos de contexto para entender tus convenciones. Crea un ~/.pi/agent/AGENTS.md a nivel de usuario para lo que siempre es cierto, y un AGENTS.md por repositorio para los detalles del proyecto:

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

Arranca Pi y referencia archivos con @:

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

Paso 8: contenedoriza para tener un sandbox real

Como Pi no tiene sistema de permisos integrado, la contenedorización es el aislamiento práctico más fuerte. En un VPS es un seguro barato: el contenedor protege los recursos del host que no hayas expuesto explícitamente.

Instala Docker y crea 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"]

Constrúyelo y ejecútalo:

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

El montaje $PWD:/workspace expone solo el proyecto actual. El volumen con nombre pi-agent-home conserva ajustes, credenciales y sesiones locales del contenedor entre ejecuciones. Verifica el límite desde dentro de Pi con !pwd: debería imprimir /workspace. No montes tu ~/.pi/agent del host salvo que necesites específicamente la configuración existente.

Paso 9: añade una tarea de agente programada

Con Pi en un VPS de Netcup siempre activo, puedes programar trabajo autónomo. Añade una entrada de cron:

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

Fíjate en la lista blanca -t read,bash: la tarea puede inspeccionar y ejecutar comandos, pero no escribir ni editar archivos arbitrarios. Limita las herramientas al mínimo que necesite cada tarea.

Paso 10: opcional — ejecuta modelos localmente

En un servidor Netcup más grande puedes mantener la inferencia en tu propio hardware. Pi admite el router de llama.cpp de forma nativa mediante /llama. Para Ollama, LM Studio o vLLM, añádelos a ~/.pi/agent/models.json:

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

La clave de API ficticia basta para Pi; Ollama la ignora. Para endpoints autenticados, usa interpolación de variables de entorno con $NAME en lugar de valores literales.

Paso 11: haz copias de seguridad de tus sesiones

Las sesiones viven en ~/.pi/agent/sessions/, organizadas por directorio de trabajo. Son JSONL plano, fácil de archivar:

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

Combina esto con los snapshots de netcup desde el panel de control para tener puntos de restauración de todo el servidor antes de actualizaciones arriesgadas.

Elegir el servidor Netcup adecuado para alojar Pi barato

La huella de recursos de Pi es modesta: es un proceso de Node.js que recibe tokens en streaming desde una API remota. Lo que realmente consume tu servidor son los comandos que Pi ejecuta: compilaciones, suites de pruebas, imágenes de Docker, servidores de lenguaje y, si optas por lo local, la inferencia del modelo.

Así se corresponde la gama actual netcup VPS G12.5 con las cargas de trabajo de Pi.

Comparativa de VPS para Pi

Todos los niveles incluyen IPv4 + IPv6, tráfico ilimitado, snapshots, protección DDoS, acceso root completo y una consola remota fuera de banda. Ubicaciones: Núremberg, Viena, Ámsterdam, Manassas, Singapur.

Configuraciones recomendadas

VPS 1000 G12.5 — la opción por defecto para Pi

4 vCores, 8 GB de RAM ECC, 128 GB SSD por EUR 12,18/mes. Mueve Pi con holgura con unos cuantos repositorios, búsquedas con ripgrep sobre bases de código grandes, suites de pruebas de Node o Python y una sesión de tmux que dejas conectada durante semanas. Si usas modelos de Anthropic, OpenAI o Google, este es todo el servidor que Pi necesita.

Cupones para 1 mes gratis:

6877nc17911959133
6877nc17911959132
6877nc17911959130

VPS 2000 G12.5 — contenedorizado y multiproyecto

8 vCores, 16 GB de RAM ECC, 256 GB SSD por EUR 22,62/mes. El nivel adecuado en cuanto ejecutas Pi dentro de sandboxes de Docker, mantienes varios contenedores de proyecto activos o lanzas compilaciones que aprovechan de verdad el paralelismo. 16 GB dejan margen para una base de datos y un servidor de lenguaje junto al agente.

Cupones para 1 mes gratis:

6878nc17911959165
6878nc17911959164
6878nc17911959163

VPS 4000 G12.5 — sesiones de Pi en paralelo y CI

12 vCores, 32 GB de RAM ECC, 512 GB SSD por EUR 38,11/mes. Ejecuta varias sesiones de Pi independientes contra ramas distintas, cada una en su propio contenedor, además de un runner de CI en la misma máquina. El SSD de 512 GB absorbe cachés de capas de Docker, árboles de node_modules y meses de JSONL de sesiones sin necesidad de limpiar.

Cupones para 1 mes gratis:

6879nc17912008310
6879nc17911959185
6879nc17911959183

VPS 8000 G12.5 — harness de equipo e inferencia local

16 vCores, 64 GB de RAM ECC, 1 TB SSD por EUR 56,39/mes. La cima de la gama de núcleos compartidos. RAM suficiente para servir modelos GGUF de tamaño medio con llama.cpp u Ollama mientras varios desarrolladores ejecutan sus propias sesiones de Pi por SSH, cada uno con su directorio de agente separado.

Cupones para 1 mes gratis:

6880nc17911959202
6880nc17911959201
6880nc17911959200

Root Servers: núcleos dedicados para ejecuciones de agente predecibles

Si Pi ejecuta suites de pruebas o compilaciones de forma programada, los núcleos dedicados eliminan la variabilidad de la CPU compartida. La gama Root Server G12.5 de Netcup usa núcleos AMD EPYC 9645 con almacenamiento NVMe.

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

6874nc17911959060
6874nc17911959065
6874nc17911959064

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

6875nc17912005420
6875nc17911959085
6875nc17911959084

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

6876nc17911959105
6876nc17911959104
6876nc17911959103

Cómo decidir

Empieza con el VPS 1000 G12.5. El proceso del agente Pi es pequeño; el servidor existe para ejecutar tu cadena de herramientas. Sube de nivel solo cuando choques con un muro real:

• Te quedas sin RAM durante las compilaciones — pasa al VPS 2000 G12.5
• Las compilaciones resultan inconsistentes en horas punta — pasa a un Root Server con núcleos dedicados
• Más de dos o tres contenedores de Pi simultáneos — pasa al VPS 4000 G12.5
• Sirves modelos GGUF locales mediante /llama — ve directamente al VPS 8000 G12.5 o al RS 8000 G12.5, donde la RAM es el factor limitante

Dimensionar el disco. Los archivos JSONL de sesión son diminutos. Lo que crece son las capas de Docker, las cachés de dependencias y los repositorios clonados. 128 GB es generoso para un puñado de proyectos; si replicas monorepos grandes, sube un nivel o añade Local Block Storage de netcup.

Ubicación. Elige el centro de datos más cercano. La TUI de Pi es interactiva y cada pulsación cruza la red: 20 ms se sienten instantáneos, 200 ms no.

Optimización de costes

1. Aplica un cupón en cada primer pedido. Un mes gratis en un VPS 2000 G12.5 son EUR 22,62 que te quedas.
2. Usa facturación por horas para experimentar. Levanta un servidor, prueba una extensión de Pi, destrúyelo.
3. Comprométete a 12 meses para obtener la tarifa mensual más baja una vez que tu configuración esté asentada.
4. Empieza pequeño y escala. Netcup facilita las ampliaciones; sobredimensionar el primer día es dinero desperdiciado.
5. Acumula 36nc17718015540 para EUR 5 de descuento en cualquier pedido cuando no haya cupón de mes gratis para el nivel elegido.

Resumen de cupones

Encontrarás más códigos actualizados siempre en netcup.best.

Conclusión

Pi es el harness de agente para quien quiere entender y controlar sus herramientas. Un núcleo de cuatro herramientas, un bucle de agente documentado, sesiones como árboles JSONL legibles y una API de extensiones que te deja añadir exactamente las capacidades que necesitas —subagentes, modo de planificación, puertas de permisos— en lugar de heredar los valores por defecto de otro. Tiene licencia MIT, se instala con un comando y habla con más de 15 proveedores de modelos además de cualquier endpoint local al que lo apuntes.

Ese mismo minimalismo trae una contrapartida que Pi declara abiertamente: sin sandbox integrado, sin aprobación por llamada, con todos los permisos del usuario. Ejecutarlo en tu máquina personal significa entregarle a una herramienta bash dirigida por un LLM las llaves de todo lo que posees.

Autoalojar Pi en un VPS de Netcup resuelve eso con limpieza. Un servidor dedicado es un radio de daño controlado: contiene solo los repositorios y las credenciales de corta duración que la tarea realmente requiere, se puede fotografiar con un snapshot antes de cualquier operación arriesgada y se puede reconstruir desde cero en minutos si algo sale mal. Añade contenedorización con Docker encima y tendrás el aislamiento que Pi deja deliberadamente en manos del operador.

Las ventajas prácticas se acumulan rápido:

• Siempre encendido. Lanza una refactorización larga dentro de tmux, cierra el portátil y reconéctate mañana desde el móvil.
• Realmente aislado. El agente toca un servidor desechable, no tu sistema de archivos personal, tus claves SSH ni tu gestor de contraseñas.
• Automatizable. --print, --mode json y --mode rpc junto a cron convierten tu VPS en un operario de mantenimiento autónomo que limita su propio acceso a herramientas.
• Rápido y cerca de tus datos. 2,5 Gbit/s con tráfico ilimitado, almacenamiento NVMe o SSD y cinco ubicaciones de centros de datos.
• Recuperable. Snapshots, consola remota fuera de banda y acceso root completo significan que ningún bloqueo es permanente.
• Privado por defecto. Con un endpoint local de llama.cpp u Ollama en un nivel superior, tu código nunca sale de una infraestructura que controlas.

Y es barato. Un VPS 1000 G12.5 a EUR 12,18/mes ejecuta Pi, tu cadena de herramientas y tus repositorios con margen de sobra: mucho menos que un solo mes de la mayoría de plataformas alojadas de desarrollo con IA, y toda la pila es tuya. Con un cupón, el primer mes no cuesta nada:

6877nc17912005430
6877nc17911959135
6877nc17911959133

La promesa de Pi es que el harness es tuyo. Ponlo en un servidor que también lo sea.