Reseña del agente de codificación Pi: una CLI de IA minimalista y hackeable

Pi Coding Agent es un arnés de codificación por terminal minimalista y de código abierto que incluye cuatro herramientas predeterminadas y deja la mayor parte del comportamiento a las extensiones, habilidades y a tu propio flujo de trabajo.

La mayoría de los agentes de codificación con IA se están convirtiendo en productos más grandes. Añaden modos de planificación, subagentes, capas de permisos, integraciones con IDE, trabajadores en segundo plano y una orquestación cada vez más elaborada alrededor del modelo. Pi adopta un enfoque casi opuesto: el agente predeterminado comienza con cuatro herramientas básicas — read, write, edit y bash — mientras que la mayor parte del comportamiento interesante se deja deliberadamente a las extensiones, habilidades, paquetes y a tu propio flujo de trabajo.

Esta reseña está alineada con Pi v0.84.2, lanzada el 14 de agosto de 2026. Mario Zechner creó el proyecto; se trasladó a Earendil Works en mayo de 2026, por lo que los paquetes actuales usan el ámbito @earendil-works en lugar de los nombres antiguos @mariozechner. Pi ha estado cambiando rápidamente, por lo que las API de configuración y extensiones merecen una verificación de versión antes de estandarizarlas en todo un equipo.

La trampa es igualmente importante: Pi te da considerablemente más control que muchos agentes de codificación, y por lo tanto más responsabilidad. No proporciona una caja de seguridad (sandbox) integrada ni el tipo de sistema de permisos que los desarrolladores pueden esperar después de usar Claude Code o herramientas similares. A continuación, cubro la iniciación rápida, la arquitectura, el soporte de modelos, las extensiones, el modelo de sesiones, las implicaciones de seguridad y dónde creo que encaja Pi entre las herramientas modernas de codificación con IA.

¿Qué es Pi Coding Agent?

Pi se entiende mejor como un arnés de agente que como un entorno de codificación terminado y con opiniones. Esa distinción importa: un modelo de codificación responde a indicaciones, mientras que un arnés de agente decide qué contexto ve ese modelo, qué herramientas puede llamar, cómo los resultados de las herramientas le devuelven, cómo persisten las sesiones y qué sucede entre turnos. Pi hace accesibles casi todas esas capas, por lo que se sitúa en el extremo de construcción de kits del campo de las herramientas de desarrollo con IA en lugar de estar entre los productos de codificación con todo incluido.

La razón más fuerte para usar Pi no es que tenga más funciones que los agentes de codificación competidores — no las tiene. La razón es que Pi expone más del propio agente. Eso lo hace particularmente atractivo para desarrolladores senior, ingenieros de plataforma, equipos de herramientas de IA y cualquiera que haya llegado al punto donde las limitaciones de su agente de codificación son causadas por el arnés en lugar del modelo subyacente. Pi es menos convincente para alguien que quiere instalar un agente, aprobar algunas configuraciones seguras predeterminadas y nunca volver a pensar en su arquitectura: su minimalismo es productivo solo si valoras el control que ese minimalismo crea.

Lo que Pi realmente te da

El conjunto de herramientas orientado al modelo predeterminado es intencionalmente pequeño:

read
write
edit
bash

Hay disponibles herramientas adicionales de solo lectura, incluyendo grep, find y ls, y las versiones recientes de Pi permiten configurar la selección inicial de herramientas integradas.

El aspecto predeterminado parece escaso, y ese es el punto. Cada herramienta adicional aumenta el número de decisiones que el modelo debe tomar, expande el prompt del sistema y crea otra superficie de comportamiento que puede necesitar depuración. En cambio, Pi comienza desde un conjunto primitivo capaz y te permite agregar herramientas especializadas cuando tu flujo de trabajo realmente las necesita.

La filosofía se extiende más allá de las herramientas. Pi deliberadamente no hace que los subagentes integrados o un modo de planificación obligatorio sean centrales para el producto; esos comportamientos pueden implementarse a través de extensiones o paquetes instalados en su lugar. Eso hace que Pi sea menos conveniente al salir de la caja, pero da a los desarrolladores más control sobre cómo se implementan esos mecanismos. Si estás acostumbrado a los subagentes integrados de Claude Code, la guía de subagentes de Claude Code es una referencia útil para lo que estarías reimplantando. Encuentro ese enfoque ligeramente refrescante: Pi no finge que hay una única forma correcta de operar un agente de codificación con IA.

Cómo instalar Pi Coding Agent e iniciar una sesión

Instala el paquete actual desde el ámbito @earendil-works. Los tutoriales antiguos aún pueden mostrar paquetes @mariozechner de antes del traslado de mayo de 2026; esos nombres están desactualizados para nuevas instalaciones.

El nombre también colisiona con oh-my-pi, un fork comunitario del arnés Oh My Opencode. Ese proyecto no está relacionado con este agente de codificación; la reseña de Oh My Opencode explica el fork si llegaste al Pi equivocado.

Instalar y autenticar

1. Instala Pi globalmente con npm:

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

   --ignore-scripts desactiva los scripts de ciclo de vida de dependencias durante la instalación. Pi no necesita esos scripts para una instalación npm normal, y omitirlos reduce un riesgo común de cadena de suministro.

2. Verifica la instalación:

   pi --version
   

3. Entra en un proyecto e inicia:

   cd /path/to/project
   pi
   

Pi espera un entorno con capacidad bash. En Windows, usa WSL o Git Bash en lugar de cmd.exe.

Pi admite autenticación de suscripción interactiva así como proveedores basados en clave API. Dentro de Pi, la ruta más simple es:

/login

Después de la autenticación, selecciona un modelo con:

/model

También puedes proporcionar credenciales del proveedor a través de variables de entorno. Por ejemplo:

export ANTHROPIC_API_KEY="your-api-key"
pi

Pi actualmente soporta una amplia colección de proveedores de modelos, incluyendo OpenAI, Anthropic, Google, Azure OpenAI, Amazon Bedrock, NVIDIA NIM, DeepSeek, Mistral, Groq, Cerebras, Cloudflare, xAI, OpenRouter y varios otros. También se soporta un enrutador de llama.cpp para modelos servidos localmente: la iniciación rápida de llama.cpp cubre el servicio de modelos GGUF con una API compatible con OpenAI, y la guía de alojamiento de LLM mapea los runtime locales, autoalojados y en la nube circundantes si quieres comparar esa ruta con Ollama, vLLM o un proveedor alojado. Los proveedores personalizados que hablan una API soportada pueden agregarse a través de ~/.pi/agent/models.json, y las API o flujos OAuth personalizados pueden conectarse con extensiones.

Este diseño multiproveedor es una de las ventajas prácticas de Pi. El modelo y el arnés de codificación son variables separadas: con Pi, puedes cambiar el modelo manteniendo esencialmente el mismo conjunto de herramientas y entorno de sesión, lo que hace que las comparaciones de modelos sean considerablemente más significativas que comparar productos de codificación completamente diferentes.

Comienza con una primera sesión controlada

No haría que tu primer prompt de Pi fuera “refactoriza mi aplicación”. Comienza pidiéndole que inspeccione en lugar de modificar:

pi --tools read,grep,find,ls -p "Inspect this repository. Explain its architecture, identify the main entry points, and list the commands you would run before making a change. Do not modify files."

Cuando ejecuté ese prompt de solo lectura en un repositorio existente, el resultado útil no fue un ensayo ingenioso sobre la arquitectura. Fue si el modelo nombró puntos de entrada reales y los comandos que realmente ejecutaría antes de solicitar acceso de escritura. Eso te da una mirada a cómo el modelo seleccionado navega tu árbol sin otorgarle inmediatamente una ruta de escritura a través del conjunto de herramientas normal.

Para trabajo interactivo, también crearía primero una rama Git desechable:

git switch -c ai/pi-evaluation
pi

Pi puede modificar archivos en el directorio de trabajo y puede ejecutar comandos de shell a través de bash, por lo que Git sigue siendo una de las capas de reversión práctica más simples al evaluarlo. Si quieres una sesión de prueba que no persista, pi --no-session se ejecuta en modo efímero.

Las instrucciones del proyecto pertenecen en AGENTS.md. Un archivo inicial útil podría verse así:

# Project Instructions

- Read the existing implementation before modifying files.
- Keep changes narrowly scoped to the requested task.
- Run `npm test` after code changes.
- Run `npm run lint` before declaring the task complete.
- Do not modify database migrations unless explicitly requested.
- Do not access production infrastructure.
- Explain any destructive command before running it.

Pi también entiende CLAUDE.md mientras recorre los directorios del proyecto, y AGENTS.override.md puede anular las instrucciones normales del proyecto para un directorio.

Entonces, dale una tarea concreta:

Read the authentication module and its tests.

Find one maintainability problem that can be fixed without changing public behaviour. Explain the proposed change first, then implement it and run the relevant tests.

Esta es una mejor evaluación del agente que pedirle que genere una nueva aplicación de juguete. El código existente obliga al agente a descubrir restricciones, preservar el comportamiento, elegir archivos relevantes y verificar su trabajo.

Por qué Pi Coding Agent es un arnés editable

La idea arquitectónica más importante de Pi es que el propio agente de codificación debería permanecer editable. El sistema de extensiones usa módulos de TypeScript que pueden registrar herramientas, suscribirse a eventos de ciclo de vida, interceptar llamadas de herramientas, inyectar o transformar contexto, agregar comandos y modificar la interfaz de terminal. Las extensiones locales del proyecto también pueden recargarse con /reload, lo que hace que experimentar con el arnés sea sorprendentemente inmediato.

En forma simplificada, Pi se ve así:

El diagrama es simple porque Pi intenta mantener el plano de control simple. Eso te da una opción inusual: cuando el agente carece de una capacidad, no necesariamente tienes que esperar a que los mantenedores de Pi la agreguen — puedes agregar el comportamiento tú mismo. Una extensión puede crear una nueva herramienta invocable por el modelo, inspeccionar una llamada bash propuesta y bloquear comandos que coincidan con tu propia política, insertar información dinámica del proyecto antes de un turno, alterar el comportamiento de compactación o exponer un comando personalizado dentro de la interfaz de usuario de terminal. Eso es una superficie de extensión mucho más profunda que cambiar un prompt del sistema.

La integración de MCP no se trata como una parte integrada obligatoria del núcleo minimalista de Pi. Puede agregarse a través del mismo modelo de extensibilidad, lo cual es consistente con el diseño más amplio: las integraciones especializadas viven por encima del pequeño arnés predeterminado en lugar de expandirlo permanentemente.

El mismo arnés también es reutilizable fuera de la terminal interactiva. Pi incluye un SDK para incrustar la sesión del agente en aplicaciones Node.js, y un modo RPC (pi --mode rpc) que habla JSON sobre stdin/stdout para hosts no Node, IDE e interfaces de usuario personalizadas.

La idea de cuatro herramientas es más seria de lo que parece

Inicialmente pensé en las herramientas de agentes de codificación en dos grupos. El primero contiene primitivas: leer un archivo, modificar un archivo y ejecutar un comando. El segundo contiene comodidades: búsqueda de repositorio, ejecutores de pruebas, rastreadores de problemas, herramientas de navegador, herramientas de despliegue, asistentes de base de datos, inteligencia de código y planificadores especializados. Pi mantiene la capa de primitivas pequeña y permite que la capa de comodidades permanezca opcional.

Hay una ventaja arquitectónica en esto. Un equipo que trabaja en infraestructura de Kubernetes puede construir un Pi muy diferente de un equipo que mantiene un monorepo de TypeScript, sin que ambos equipos carguen las herramientas del otro en el mismo agente predeterminado. Es aquí donde Pi deja de verse como una alternativa reducida de Claude Code y comienza a verse como un marco para construir tu propio agente de codificación.

El precio es el mantenimiento. Una vez que dependes de extensiones personalizadas, su comportamiento se convierte en parte de tu plataforma de desarrollo: necesitas revisarlas, versionarlas y ocasionalmente actualizarlas a medida que Pi evoluciona. Esa es la tarifa oculta de Pi — ganas la propiedad del agente, y la propiedad viene con mantenimiento.

Las habilidades y los paquetes mantienen la personalización modular

No cada comportamiento personalizado necesita convertirse en una extensión. Pi soporta habilidades que empaquetan instrucciones, scripts y material de referencia alrededor de una capacidad. Las habilidades usan revelación progresiva: Pi puede publicitar la habilidad disponible al modelo mientras carga las instrucciones completas solo cuando se necesita la capacidad. Eso es útil para flujos de trabajo como revisiones de despliegue, migraciones de base de datos, preparación de lanzamientos o revisión de código específica de marcos de trabajo; en lugar de inyectar permanentemente páginas de instrucciones en cada conversación, el agente puede cargar orientación especializada bajo demanda. Si ya construyes Claude Skills, la mecánica se sentirá familiar — mira Claude Skills y SKILL.md para desarrolladores para la disposición de SKILL.md y el ajuste de disparadores.

Los Paquetes de Pi van más allá al empaquetar extensiones, habilidades, plantillas de prompts y temas. Los paquetes pueden instalarse desde npm o repositorios Git y pueden fijarse a versiones específicas:

pi install npm:@foo/pi-tools@1.2.3
pi list

El modelo de paquetes es poderoso, pero trata los paquetes más como herramientas de desarrollo ejecutables que como colecciones inofensivas de prompts. Una extensión de Pi puede ejecutar código con los permisos del proceso de Pi, y una habilidad también puede instruir al modelo a ejecutar código, por lo que instalar un paquete desconocido merece esencialmente la misma sospecha que instalar una dependencia de desarrollo desconocida.

Árboles de sesión en Pi Coding Agent

Muchos asistentes de codificación tratan una conversación como un transcurso mayoritariamente lineal. Pi almacena las sesiones como un árbol, lo que significa que puedes volver a un punto anterior, intentar otro enfoque y retener ambos caminos dentro de la sesión en lugar de destruir un historial o crear un montón de chats no relacionados.

Los comandos principales son straightforward:

/resume
/tree
/fork
/clone
/compact

/tree te permite navegar dentro del árbol de la sesión actual. /fork crea una nueva sesión desde un mensaje de usuario anterior, mientras que /clone duplica la rama actualmente activa en una sesión separada. Desde la línea de comandos, pi -c continúa la sesión más reciente y pi -r explora las pasadas.

La distinción se volvió obvia la primera vez que usé Pi en un paso de depuración en lugar de un prompt de campo verde. Dejé que siguiera una hipótesis de capa de caché para una prueba de integración fallida, luego hice un fork desde el mensaje donde se había elegido esa teoría y comencé una segunda rama en aislamiento de transacciones. La investigación fallida permaneció disponible para contraste en lugar de contaminar la nueva ruta o forzar un chat nuevo, lo cual es una representación útil de cómo funciona realmente la depuración: a menudo existen múltiples explicaciones plausibles al mismo tiempo.

Pi persiste las sesiones como JSONL y puede compactar automáticamente el contexto más antiguo a medida que las conversaciones se acercan a los límites del modelo; las ramas también pueden resumirse cuando te mueves entre ellas. Clasificaría esto por encima de varias funciones de agentes de codificación más visibles: una buena gestión de contexto suele importar más que otro botón en la interfaz.

La ingeniería de contexto es una capacidad de primera clase

Pi también hace posible personalizar lo que llega al modelo. Las extensiones pueden inyectar información antes de los turnos, alterar el historial y participar en la compactación. El sistema de compactación predeterminado resume el material más antiguo mientras retiene la conversación reciente, pero el mecanismo puede reemplazarse o personalizarse.

Para equipos avanzados, esto abre posibilidades interesantes. Un monorepo grande podría inyectar información de propiedad solo para los archivos que el agente está tocando actualmente. Un proyecto de backend podría mostrar metadatos de esquema cuando los archivos de base de datos entran en el contexto. Un agente de migración de larga duración podría mantener un estado estructurado fuera de la conversación en lugar de pedirle repetidamente al modelo que lo redescubra. Esto es lo que considero la fortaleza a largo plazo real de Pi: la calidad del agente de codificación está cada vez más limitada por la ingeniería de contexto, el diseño de herramientas y la orquestación en lugar de la inteligencia bruta del modelo, y Pi da a los desarrolladores un acceso inusualmente directo a esas capas.

Seguridad de Pi Coding Agent: sin sandbox integrada

El punto negativo más importante en esta reseña es simple: Pi no proporciona una sandbox de seguridad integrada. Por defecto, Pi se ejecuta con los permisos del usuario y proceso que lo iniciaron. Sus herramientas pueden leer y modificar archivos accesibles y ejecutar comandos de shell dentro de ese contexto de sistema operativo.

Pi sí tiene confianza de proyecto, pero la confianza de proyecto no es una sandbox. La confianza de proyecto controla si se cargan la configuración local de Pi, extensiones, habilidades, prompts y recursos similares del proyecto. Una vez que estás trabajando en un proyecto, no crea un límite de sistema de archivos, red, proceso o credenciales alrededor de las llamadas a herramientas dirigidas por el modelo. De hecho, aprecio que la documentación de Pi sea explícita sobre esta distinción: una pseudo-sandbox débil puede ser más peligrosa que ninguna sandbox porque los usuarios pueden confiar en un límite que realmente no existe. Pi espera en cambio que el aislamiento significativo provenga de contenedores, máquinas virtuales, micro-VM u otro runtime controlado por política.

Para proyectos personales desechables, puedes decidir que Git y los permisos normales del sistema operativo son suficientes. Para repositorios no confiables, agentes sin supervisión, estaciones de trabajo que contienen credenciales de producción o agentes que procesan contenido suministrado externamente, usaría un aislamiento más fuerte. La documentación de Pi describe tres patrones:

El límite importante no es solo el directorio de origen. Un agente que puede ejecutar comandos de shell puede potencialmente interactuar con la configuración SSH, credenciales de la nube, registros de paquetes, servicios locales, estado del navegador y cualquier otra cosa disponible para el proceso. Una configuración de calidad de producción, por lo tanto, necesita pensar juntos sobre las monturas de sistema de archivos, variables de entorno, acceso a red y credenciales. Mi patrón de evaluación preferido es:

Montar el repositorio real en modo lectura/escritura en un contenedor aún permite al agente modificar ese repositorio; los contenedores solo ayudan en la medida en que sus monturas, credenciales, capacidades y acceso a red están realmente restringidos. Gondolin tiene una salvedad relacionada: las herramientas de extensiones personalizadas aún se ejecutan en el host a menos que también deleguen en la VM.

Hay otra superficie de seguridad que vale la pena recordar: extensiones y paquetes. Una extensión de terceros es código que se ejecuta dentro del entorno del agente. Revísala antes de la instalación, fija las dependencias importantes y evita tratar una galería pública de paquetes como una revisión de seguridad implícita.

Dos comprobaciones prácticas antes de ejecutar Pi en una máquina que te importa:

# Confirm the version you actually have
pi --version

# Disable startup network operations (update checks and install telemetry)
export PI_OFFLINE=1
pi

PI_OFFLINE=1 desactiva todas las operaciones de red de inicio, incluyendo comprobaciones de actualización, comprobaciones de actualización de paquetes y telemetría de instalación/actualización. Si quieres una división más fina, PI_SKIP_VERSION_CHECK=1 desactiva solo la comprobación de versión, y PI_TELEMETRY=0 desactiva la telemetría de instalación/actualización dejando habilitadas las comprobaciones de actualización.

Este modelo de seguridad es la principal razón por la que dudaría antes de dar Pi a una gran organización de ingeniería como predeterminado no gestionado. Pi proporciona las piezas para construir un entorno fuerte, pero intencionalmente deja gran parte de ese entorno a ti.

Pi Coding Agent vs Claude Code y OpenCode

Pi tiene más sentido cuando se compara por filosofía en lugar de por número de funciones. Entre los agentes de terminal, OpenHands es el pariente más cercano: también se ejecuta desde el CLI, pero incluye sandboxing y un flujo de trabajo integrado más grande en lugar de pedirte que armes uno. Claude Code tiene permisos integrados, hooks y subagentes cada vez más sofisticados. OpenCode expone reglas configurables de permitir, preguntar y denegar más conceptos integrados de agente o subagente. Pi comienza más bajo en el stack.

Esta es la razón por la que llamar a Pi un “clon de Claude Code” pasa por alto la parte interesante. Si estás contento con el flujo de trabajo de Claude Code, Pi no lo mejora automáticamente: Claude Code te da más seguridad y comportamiento de orquestación de agente sin requerirte que armes esas piezas tú mismo. Pi se vuelve interesante cuando quieres cambiar los supuestos debajo del producto. Quizás quieres el mismo arnés a través de Anthropic, OpenAI y modelos locales. Quizás tu organización tiene su propia sandbox. Quizás necesitas una herramienta que inyecte metadatos de arquitectura interna antes de cada turno. Quizás quieres que la compactación produzca un estado de ingeniería estructurado en lugar de un resumen de conversación genérico. Eso es territorio de Pi.

OpenCode es filosóficamente más cercano porque también ofrece configuración sustancial. Incluso allí, Pi se siente más como un kit para construir el propio arnés, mientras que OpenCode expone más conceptos de agente y permisos hechos a medida.

No hay un ganador universal aquí. Para muchos desarrolladores, las configuraciones predeterminadas con opiniones de Claude Code son una ventaja. Para otros, OpenCode puede ofrecer un punto medio mejor. Pi es la opción que investigaría cuando la frase “ojalá mi agente de codificación funcionara de manera diferente” se ha vuelto más importante que “ojalá mi agente de codificación tuviera otra función”.

¿Deberías usar Pi Coding Agent?

Pi Coding Agent es uno de los agentes de codificación más técnicamente interesantes porque se niega a ocultar el arnés. La implementación predeterminada es deliberadamente pequeña, pero la API de extensiones, habilidades, paquetes, capa de proveedor, SDK, modo RPC y árbol de sesión le dan una superficie efectiva mucho más grande de lo que sus cuatro herramientas predeterminadas sugieren.

Recomendaría Pi con más fuerza a desarrolladores experimentados que les guste construir sus propias herramientas. Es particularmente convincente para trabajo de plataforma de IA, investigación experimental de agentes de codificación, flujos de trabajo de ingeniería especializados y equipos que ya tienen infraestructura de ejecución segura. También es útil para desarrolladores que quieren comparar modelos sin cambiar su entorno de codificación completo cada vez. Sería más cauteloso para principiantes y para organizaciones que esperan controles de política de estilo empresarial inmediatamente después de la instalación.

La sandbox que falta cambia cómo Pi debería desplegarse, especialmente cuando se permite que un agente opere sin supervisión o puede encontrarse con instrucciones no confiables. Trata Pi como un proceso de desarrollo local poderoso en lugar de un límite de seguridad: para repositorios no confiables, operación sin supervisión o entornos que contienen credenciales valiosas, usa una sandbox basada en sistema operativo, contenedor, VM o política y expone solo los recursos necesarios para la tarea.

Mi calificación general es 8.4/10. Eso es un veredicto editorial en lugar del promedio de la tabla anterior, y podría fácilmente volverse más alto para el usuario adecuado. La mayor debilidad y la mayor fortaleza de Pi son la misma cosa: no termina el agente por ti.

¿Deberías cambiar de Claude Code? No automáticamente. Usa Claude Code cuando sus permisos integrados, subagentes, hooks y flujo de trabajo encajan con la forma en que ya trabajas. Evalúa Pi cuando quieres una propiedad más amplia del arnés, selección de proveedor, construcción de contexto y arquitectura de herramientas. Para desarrolladores avanzados, ni siquiera asumiría que la elección tiene que ser exclusiva: Claude Code puede permanecer como el conductor diario pulido mientras Pi se convierte en el laboratorio de agentes programables. Después de suficiente personalización, ese laboratorio puede convertirse en la herramienta que realmente prefieres.

Licencia y costo

Pi mismo es de código abierto y se libera bajo la licencia MIT. Eso no hace que la inferencia del modelo sea gratuita: tu costo real depende del proveedor del modelo, el uso de API, la autenticación de suscripción soportada, la computación local y cualquier infraestructura de sandbox que elijas ejecutar.

Referencias

• Repositorio de Pi Coding Agent: https://github.com/earendil-works/pi
• Sitio web e instalador de Pi: https://pi.dev
• Paquete npm: https://www.npmjs.com/package/@earendil-works/pi-coding-agent
• Micro-VM Gondolin: https://github.com/earendil-works/gondolin
• NVIDIA OpenShell: https://docs.nvidia.com/openshell/about/overview
• Licencia: MIT