pi-mono — Summary

pi-mono is the official monorepo for the pi coding agent ecosystem by Earendil Works (badlogic / Mario Zechner). It ships four TypeScript packages: @earendil-works/pi-coding-agent (interactive TUI CLI), @earendil-works/pi-agent-core (agent runtime with tool calling), @earendil-works/pi-ai (unified multi-provider LLM API for OpenAI, Anthropic, Google, Mistral, DeepSeek, Vertex AI, Codex OAuth), and @earendil-works/pi-tui (terminal UI library with differential rendering). Pi is positioned as a minimal, extensible coding harness that adapts to developer workflows via TypeScript Extensions, Skills, Prompt Templates, and Pi Packages (npm/git). It explicitly omits sub-agents and plan mode from defaults, instead allowing developers to build or install what they need. The pi binary supports interactive, print/JSON, RPC, and SDK embedding modes. Pi is one of the few frameworks that ships a unified multi-provider LLM API as a first-class package, making it trivially easy to route different tasks to different providers within one workflow. Compared to seeds, pi-mono is closest to claude-conductor in its minimal-defaults philosophy and template-driven extension model, but surpasses it by shipping a complete agent runtime, multi-provider LLM API, and TUI library as separately usable npm packages.

pi-mono — Overview

Origin

Created by badlogic (Mario Zechner, @badlogicgames). Published as @earendil-works/pi-coding-agent. Version 0.75.5. 55,497 stars, 30 contributors. Active development (last pushed 2026-05-26). MIT license. The pi.dev domain was donated by exe.dev.

Philosophy

From the coding-agent README:

"Pi is a minimal terminal coding harness. Adapt pi to your workflows, not the other way around, without having to fork and modify pi internals. Extend it with TypeScript Extensions, Skills, Prompt Templates, and Themes."

"Pi ships with powerful defaults but skips features like sub agents and plan mode. Instead, you can ask pi to build what you want or install a third party pi package that matches your workflow."

Supply-Chain Hardening (Notable)

pi-mono implements unusually strong supply-chain protections documented in the README:

• Direct dependencies pinned to exact versions; .npmrc sets save-exact=true and min-release-age=2
• package-lock.json is the dependency ground truth; pre-commit blocks accidental lockfile changes
• Published CLI includes npm-shrinkwrap.json to pin transitive deps for npm users
• CI installs with npm ci --ignore-scripts
• npm run check verifies pinned deps, native TypeScript import compatibility, and generated coding-agent shrinkwrap
• Scheduled GitHub workflow runs npm audit and npm audit signatures

This is the most supply-chain-conscious framework in the entire batch — a direct contrast to claude-flow's IPFS injection incident.

Key Design Opinions

• Minimal defaults, maximum extensibility via typed TypeScript Extension API
• Self-describing: "you can ask pi to build what you want" — meta-extensibility
• Multi-provider LLM from day one (not bolted on later)
• OSS session sharing via Hugging Face for training data collection
• No plan mode, no sub-agents by default — install them when needed

pi-mono — Architecture

Distribution & Install

• Distribution type: npm-package (4 packages) + cli-tool
• Primary install: npm install -g --ignore-scripts @earendil-works/pi-coding-agent
• Installer alternative: curl -fsSL https://pi.dev/install.sh | sh
• Binary name: pi
• Version: 0.75.5
• License: MIT
• Required runtime: node>=18 (inferred from TypeScript + modern ESM)

Package Structure

pi-mono/
├── packages/
│   ├── coding-agent/       # @earendil-works/pi-coding-agent (the pi CLI)
│   │   ├── src/
│   │   │   ├── cli.ts      # Entry point (bin: pi)
│   │   │   ├── main.ts     # AgentSession and mode routing
│   │   │   ├── modes/
│   │   │   │   ├── interactive/   # TUI interactive mode
│   │   │   │   ├── print-mode.ts  # JSON/print mode
│   │   │   │   └── rpc/           # RPC mode for process integration
│   │   │   └── core/       # Agent session, auth, bash, compaction, extensions
│   │   └── package.json
│   ├── agent/              # @earendil-works/pi-agent-core
│   │   # Agent runtime: tool calling, state management, message handling
│   ├── ai/                 # @earendil-works/pi-ai
│   │   # Unified multi-provider LLM API
│   │   # Providers: OpenAI, Azure OpenAI, OpenAI Codex, DeepSeek, Anthropic,
│   │   #           Google, Vertex AI, Mistral
│   └── tui/                # @earendil-works/pi-tui
│       # Terminal UI library with differential rendering
├── .pi/
│   ├── extensions/
│   ├── git/
│   ├── npm/
│   ├── prompts/
│   └── skills/
│       └── add-llm-provider.md
└── scripts/

Operating Modes

Target AI Tools / Providers

Via @earendil-works/pi-ai: OpenAI, Azure OpenAI, Codex (OAuth), DeepSeek, Anthropic, Google, Vertex AI, Mistral. All providers accessible via pi /login and model selection in the TUI.

Extensibility API

TypeScript Extensions have access to the full agent session API. Pi Packages are npm packages exposing extensions, skills, prompt templates, and themes.

pi-mono — Components

CLI Commands (built-in)

Tools (default agent toolset)

4 default tools given to the model:

• read — read files
• write — write files
• edit — edit files
• bash — execute bash commands

Additional capabilities via skills, extensions, or pi packages.

Sessions

• Branching: Create session branches to explore alternatives
• Compaction: Built-in context compaction support
• Cross-provider handoffs: @earendil-works/pi-ai supports handing off conversations to different models mid-session

Skills

.pi/skills/add-llm-provider.md — skill for adding new LLM providers to pi-mono itself (meta: the repo's own development skill)

Extensions API

TypeScript Extensions can:

• Register new commands
• Add new tools
• Modify agent behavior
• Add UI components to the TUI
• Handle lifecycle events

Themes

JSON theme files in src/modes/interactive/theme/

Pi Packages

npm packages exposing extensions/skills/templates/themes. Installed via npm and auto-discovered by pi.

@earendil-works/pi-ai Highlights

• Cross-provider handoffs mid-session (context serialization)
• Image input and generation
• Thinking/reasoning mode (provider-specific)
• OAuth providers (Vertex AI, Codex)
• Browser usage support
• Streaming tool calls with partial JSON

pi-mono — Uniqueness & Positioning

Differs from Seeds

pi-mono is closest to claude-conductor in its minimal-defaults philosophy — both avoid prescribing workflows and instead provide scaffolding. However, pi-mono surpasses claude-conductor dramatically by shipping a complete agent runtime (pi-agent-core), multi-provider LLM API (pi-ai), and TUI library (pi-tui) as separately usable npm packages. Claude-conductor is 15 markdown templates; pi-mono is 4 production npm packages with a 55K-star community. The multi-provider LLM API with cross-session handoffs is unique in the seeds — no seed framework ships a provider-agnostic LLM client. The TypeScript Extension API for programmatic customization is the most powerful extensibility model in the batch, compared to spec-driver/superpowers' skill-md approach. pi-mono is also the platform on which pi-ralph (this batch's samfoy framework) is built.

Positioning

pi-mono targets developers who want a minimal, extensible coding harness that doesn't prescribe methodology — in contrast to opinionated frameworks like BMAD or superpowers. The multi-provider LLM API makes pi the right choice for teams that want provider flexibility or cost optimization through model routing. The supply-chain hardening (exact pinning, shrinkwrap, audit in CI) targets security-conscious teams.

Observable Failure Modes

• No built-in planning mode: Users must install or build plan-mode functionality. The "ask pi to build it" meta-extensibility is a philosophy, not a guarantee of reliability.
• Minimal defaults mean minimal guardrails: No TDD enforcement, no auto-validators, no commit gates by default. Quality is entirely user-responsibility.
• Extension API stability: TypeScript Extension API changes may break third-party extensions without major version bumps.
• Multi-provider complexity: Cross-provider context handoffs require understanding provider-specific capabilities and token limits; seamless in the API, but not seamless in practice.

Explicit Antipatterns (from philosophy)

• Forking pi internals to add features (use TypeScript Extensions instead)
• Installing pi with lifecycle scripts (--ignore-scripts is mandated)
• Trusting same-day npm dependencies (min-release-age=2 enforced)