Pi Coding Agent: The Minimal, Extensible AI Agent Stack for Serious Developers
The best coding agents of 2026 are not just better chatbots with file access. They are programmable work environments: part terminal, part model router, part workflow engine, part memory system. Most tools hide that machinery behind a product interface. Pi takes the opposite bet: keep the core small enough to understand, then let developers build the workflow they actually need.
Pi is a coding agent framework created by Mario Zechner, the developer behind the libGDX game framework. It powers OpenClaw, the project that went from zero to 250,000+ GitHub stars in under three months, becoming the most-starred software repository on GitHub — surpassing even React.
This is a comprehensive technical guide to Pi as it exists now: the minimal agent loop, the package system, skills, TypeScript extensions, project-local settings, Ollama integration, DeepSeek provider support, OAuth/API-key login flows, telemetry controls, and a serious production setup for people who want an agent they can inspect rather than a product they have to trust blindly.
April 2026 Update: Pi Became a Programmable Agent Kernel
Updated on April 27, 2026. The important change since the first version of this article is that Pi is no longer just "a small Claude Code alternative." The official docs now describe it as a minimal terminal coding harness that you adapt with TypeScript extensions, skills, prompt templates, themes, and installable Pi packages. The public site summarizes the same direction: 15+ providers, hundreds of models, API-key or OAuth authentication, tree sessions, AGENTS.md context loading, custom compaction, package installation, and four execution modes: interactive, print/JSON, RPC, and SDK.
The latest GitHub release visible during this update is v0.70.2, released on April 24, 2026, with the repository shown at roughly 40.8k stars and 4.8k forks. The exact numbers will keep moving, but the pattern matters more: Pi is shipping fast, and the recent changelog shows the core design hardening rather than bloating.
What Changed Recently
The recent release stream is worth reading because it shows where Pi is going:
- Package-based workflows are now first-class. You can install from npm, GitHub shorthand, HTTPS, SSH, or local paths with
pi install, pin versions with refs, update Pi and packages separately, and store project-local packages under.pi/with-l. - Skills now follow the Agent Skills standard. Pi scans global and project skill folders, exposes skills as
/skill:name, loads full skill instructions on demand, and can even point at Claude Code or Codex skill directories from settings. - Extensions became the real plugin layer. Extensions can register tools, commands, shortcuts, flags, custom TUI components, event handlers, custom compaction, permission gates, path protection, Git checkpointing, SSH execution, and provider integrations.
- Provider selection is more serious. Pi supports API-key providers and subscription/OAuth flows through
/login, with built-in provider lists updated per release. Recent notes include OpenRouter routing controls, Bedrock bearer-token auth, service-tier accounting fixes, prompt-cache affinity improvements, better model-specific thinking mappings, and built-in DeepSeek provider support for V4 Flash/Pro models viaDEEPSEEK_API_KEY. - The login and model UX is improving. The
v0.70stream adds fuzzy-search provider login, clearer auth-source labels, refreshed default model selection, and better warnings that send users to/loginwhen a model or credential is missing. - Long-running inference is easier to control. Provider request timeout/retry controls now live under , which matters for local inference, overloaded providers, and long reasoning runs.
The practical reading: Pi is not trying to accumulate built-in features. It is turning the core into a stable substrate where the real workflow lives in project context, packages, extensions, and skills.
The Current Pi Stack
| Layer | What to configure | Why it matters |
| --- | --- | --- |
| AGENTS.md | Project rules, commands, architecture, forbidden actions | Always-loaded context without hiding instructions from the user |
| .pi/settings.json | Project defaults, model, thinking level, packages, skills, compaction, retries | Reproducible team setup instead of personal terminal folklore |
| .pi/extensions/ | TypeScript hooks, tools, commands, safety gates, UI widgets | The place to build features Pi intentionally refuses to bake in |
| .pi/skills/ or .agents/skills/ | On-demand deep workflows, scripts, references | Progressive disclosure without burning context on every turn |
| .pi/prompts/ | Slash-command templates for recurring work | Repeatable high-quality prompts without copy-paste |
| .pi/themes/ | Visual style | Mostly ergonomics, but useful when the TUI is open all day |
| models.json | Custom providers, OpenAI-compatible endpoints, Ollama/vLLM gateways | Lets Pi route across hosted, local, and self-hosted models |
This is why Pi feels different from a product. A product decides the workflow for you. Pi gives you a small harness and asks you to make the workflow explicit.
What the v0.70 Releases Mean in Practice
The v0.70 line is not a cosmetic bump. It moves Pi closer to being a real agent operating system:
- DeepSeek V4 becomes a first-class provider path. If you are testing
deepseek-v4-proordeepseek-v4-flash, Pi can now treat DeepSeek like a configured provider instead of a custom OpenAI-compatible workaround. - Provider failures become tunable. Timeout and retry controls belong in settings, not in scattered shell wrappers. This is especially important for local models, cloud models under load, and long-context requests.
- Model selection becomes less fragile. Searchable
/login, provider labels, and refreshed model defaults reduce the operational friction that usually makes multi-provider agents annoying. - Terminal behavior becomes more conservative. Progress reporting is now opt-in, which is the correct default for terminals, multiplexers, remote shells, and recorded sessions.
The theme is consistent: Pi is adding control surfaces, not hidden automation. That is exactly what a serious coding-agent runtime should do.
The Origin: Frustration as a Design Principle
Mario Zechner's frustration was specific and technical. Claude Code — the tool he used daily — had become, in his words, "a spaceship with 80% of functionality I have no use for." The problems were concrete:
- System prompt instability: the prompt and tool definitions changed with every release, silently breaking carefully engineered workflows.
- Context engineering blindness: the harness injected content into the context window without showing it in the UI, making it impossible to understand what the model actually saw.
- Tool proliferation: dozens of overlapping tools competed for the model's attention, consuming context budget on descriptions alone.
His thesis: if you strip a coding agent down to its absolute minimum — a tiny system prompt, four tools, and full context transparency — frontier models will perform better, not worse. The training data already contains everything the model needs to know about being a coding agent.
The results proved him right. Pi with Claude Opus achieved competitive results against Codex, Cursor, and Windsurf on Terminal-Bench 2.0 — with a system prompt under 100 tokens and exactly four tools.
Pi vs The World — Positioning
The positioning is deliberate. Pi occupies a space that no other tool claims: maximum extensibility with minimum core. It is not competing with Claude Code on features — it is arguing that most of those features should not exist in the harness at all.
The chart above tells the story visually. When your system prompt consumes 10,000 tokens, that is 10,000 tokens the model cannot use for your actual code. Pi's approach: give the model the tools, give it your project context (AGENTS.md), and let it work.
The Monorepo: A Layered Architecture
Pi lives in badlogic/pi-mono — a TypeScript monorepo with npm workspaces and strictly enforced layered dependencies. The dependency graph is a DAG: foundation packages have zero internal dependencies, and each layer can only depend downward.
This architecture is not accidental. Each package is independently usable. You can use pi-ai alone for batch LLM processing without any agent infrastructure. You can use pi-agent-core to embed a ReAct loop in your own application without the TUI. The layers are composable, not monolithic.
pi-ai: The Unified LLM API
The foundation of everything. pi-ai maps 15+ LLM providers to a single, unified interface — and it does this by recognising a fundamental truth:
The API Surface
import { complete, completeStreaming } from "@mariozechner/pi-ai";
// Simple completion
const response = await complete({
provider: "anthropic",
model: "claude-sonnet-4-20250514",
messages: [{ role: "user", content: "Explain Pi in one sentence." }],
});
// Streaming with abort support
const stream = completeStreaming({
provider: "openai",
Context Handoff — The Killer Feature
Pi's most unique capability: sessions can span multiple LLM providers in the same conversation. When you switch from Claude to GPT mid-session, the entire context — including thinking traces — is serialised and reformatted for the new provider.
// Start with Claude for complex reasoning
const msg1 = await complete({
provider: "anthropic",
model: "claude-sonnet-4-20250514",
messages: conversationHistory,
});
// Switch to a cheaper model for routine tasks
const msg2 = await complete({
provider: "openai",
model: "gpt-4.1-mini",
messages: [...conversationHistory, msg1],
// Thinking traces auto-converted to tagged text
});This is not just provider switching — it is full state preservation across fundamentally different API formats. No other unified LLM library implements this.
Split Tool Results
Another Pi innovation: tool results can return separate content for the LLM and the UI. The model receives a concise text summary; the TUI receives structured data for rich visualisation:
const tool = {
name: "search_codebase",
execute: async (args) => {
const results = await searchFiles(args.query);
return {
llm: `Found ${results.length} matches in ${results.map(r => r.file).join(", ")}`,
ui: { type:
pi-agent-core: The ReAct Loop in ~200 Lines
Every agentic system — from Claude Code to OpenClaw to Pi — implements the ReAct (Reasoning + Acting) pattern, introduced by Yao et al. at Princeton/Google in 2022. The key insight: LLMs perform significantly better when they can reason, act, observe, and reason again, compared to single-pass responses.
Pi's implementation is minimal and fully inspectable.
The Loop, Simplified
// Pseudocode of Pi's agent loop (actual: ~200 lines of TypeScript)
async function agentLoop(messages, tools, model) {
while (true) {
// 1. REASON: Ask the LLM what to do
const response = await complete({ model, messages, tools });
// 2. Check: Is the model done? (text response, no tool calls)
if (!response.toolCalls?.length) {
return response.text; // Final answer
}
// 3. ACT: Execute each tool call
const toolResults = await Promise
Tool Validation Pipeline
Every tool call passes through a rigorous validation pipeline. TypeBox schemas provide compile-time type safety AND runtime validation with detailed error messages when tool arguments fail:
import { Type } from "@sinclair/typebox";
const ReadTool = {
name: "read",
description: "Read file contents",
schema: Type.Object({
path: Type.String({ description: "Absolute file path" }),
offset: Type.Optional(Type.Number({ minimum: 0 })),
limit: Type.Optional(Type
Message Queuing: Steering vs Follow-Up
While the agent streams, users can inject messages without waiting. Pi supports two fundamentally different injection modes:
Steering interrupts the current generation and redirects the agent. Follow-up waits for the current turn to complete, then the message is processed in the next turn. This distinction matters enormously in practice — it is the difference between "stop, do this instead" and "also, when you're done with that..."
The 4 Core Tools — And Why Only 4
No search_codebase. No get_git_history. No list_directory. The model uses bash for anything that is not file I/O. This works because:
- Frontier models already know these tools. They have been RL-trained extensively on coding agent scenarios.
- Every additional tool competes for context space. Tool descriptions are expensive — they sit in every request.
- Bash is universal.
grep -r,find .,git log— the model already knows these commands intimately.
Optional Read-Only Tools
For safe exploration sessions (e.g., onboarding to a new codebase), Pi offers read-only mode:
pi --tools read,grep,find,lsThis disables write, edit, and bash — the agent can explore but cannot modify anything. Ideal for code review or architecture discovery.
Sessions: The JSONL Tree
Pi sessions are stored as append-only JSONL files where each line is a node with an id and parentId. This creates a tree structure that enables branching: you can return to any previous point and continue, creating a new branch while preserving all previous branches in the same file.
{"id":"a1","parentId":null,"role":"user","content":"Fix the auth bug"}
{"id":"a2","parentId":"a1","role":"assistant","content":"Let me read..."}
{"id":"a3","parentId
Node b1 branches from a2, creating an alternate timeline. Both paths coexist in the same file. The SessionManager API provides operations for listing, creating, resuming, and branching sessions.
Compaction: Infinite Session Length
When a session approaches 80% of the context window (configurable), Pi triggers compaction. Older messages are replaced by a summary generated by a cheap model (e.g., Claude Haiku). This enables unlimited session length without quality degradation:
The compaction threshold is configurable — and the summary model can be different from the primary model. In practice, using Haiku for compaction summaries while running Opus for reasoning provides excellent quality at minimal cost.
The 4 Operating Modes
All four modes share a single abstraction: AgentSession. The modes differ only in their I/O layer.
SDK Mode: How OpenClaw Uses Pi
OpenClaw — the 250K+ star personal AI assistant — uses Pi's SDK mode. It does not spawn Pi as a subprocess. It imports and instantiates Pi directly, giving full lifecycle control:
import { createAgentSession } from "@mariozechner/pi-agent-core";
const session = createAgentSession({
provider: "anthropic",
model: "claude-sonnet-4-20250514",
tools: [...defaultTools, ...customTools],
extensions: [securityAudit, messageFormatter],
onMessage: (msg) => gateway.send(channel, msg),
});
// Handle incoming message from WhatsApp/Telegram/Slack
This is the pattern that made OpenClaw possible. Peter Steinberger's "weekend hack" plugged Pi's agent core into a multi-platform messaging gateway — and the result went viral because the underlying agent engine (Pi) was solid enough to handle real-world, multi-channel workloads.
The Extension System
Extensions are TypeScript modules loaded by jiti — a runtime TypeScript/ESM transpiler that works without a build step. This enables hot-reload: edit the .ts file, type /reload, and changes are live immediately.
Extension Structure
// my-extension.ts
import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
import { Type } from "typebox";
export default function (pi: ExtensionAPI) {
// Add a custom slash command
pi.registerCommand("review", {
description: "Review staged changes",
handler: async (_args, ctx) => {
ctx.ui.notify("Run git diff --staged, then ask Pi to review the diff.
The Self-Extension Paradigm
This is Pi's most radical capability. Because extensions are TypeScript loaded without a build step, the agent can write and hot-reload its own extensions. The workflow:
- You describe what you want: "I need a
/deploycommand that runs our staging pipeline" - Pi writes the extension as a
.tsfile - You type
/reload - Pi tests the new command
- If it fails, Pi reads the error, fixes the code, reloads, and retries
Armin Ronacher (creator of Flask and Jinja2) described this as "software that is malleable like clay." All of his Pi extensions — /answer, /todos, /review, /files — were written by Pi itself, not by Armin. He described the requirements, pointed the agent to examples, and Pi implemented them autonomously.
The System Prompt: ~100 Tokens
This is the actual Pi system prompt, reproduced from source. Compare this with Claude Code's ~10,000 tokens:
You are an AI coding assistant. You help users with software engineering tasks.
Use the provided tools to accomplish tasks.
That is it. The rest of the context budget is allocated to:
The hierarchy loads in this order:
- System prompt (~100 tokens)
- Tool definitions (~900 tokens)
AGENTS.mdfiles (project-specific context, user-controlled)- Skills (progressive disclosure — loaded on demand)
- Conversation history (the bulk of the context)
The user controls the majority of the context budget through AGENTS.md. This is the opposite of Claude Code's approach, where the harness controls most of the context and the user gets whatever is left.
Skills: The agentskills.io Standard
Pi implements agentskills.io — an open standard for portable skill packages. Skills written for Pi work identically in Claude Code, Codex CLI, Amp, and Droid.
SKILL.md Format
---
name: code-review
version: 1.0.0
description: Automated code review with style checks
triggers:
- /review
- "review this"
---
# Code Review Skill
You are a code review assistant. When activated:
1. Read the staged git diff
2. Check for:
- Security vulnerabilities
- Performance issues
- Style violations
- Missing error handling
3. Provide actionable feedback with line referencesSkills use progressive disclosure: their full content is loaded into context only when triggered, not at session start. This keeps the baseline context lean while making deep functionality available on demand.
Current Package and Skill Surface
| Package or location | What it is | When to use it |
| --- | --- | --- |
| pi-skills | Official package of reusable Pi skills | Code review, testing, docs, and repeatable agent workflows |
| @ollama/pi-web-search | Ollama-maintained web search/fetch tools for Pi | Research workflows, SEO audits, docs verification |
| pi-autoresearch | Autonomous experiment-loop package referenced by Ollama docs | Optimizing measurable targets such as test speed, bundle size, build time, or Lighthouse score |
| .pi/skills/ | Project-local skills | Repo-specific procedures that should travel with the codebase |
| ~/.pi/agent/skills/ | Global personal skills | Personal workflows you want in every project |
| Claude Code / Codex skill directories | External skill folders configured through Pi settings | Reuse an existing skill library without duplicating files |
Agentic Patterns: 5 Ways to Use Pi
Pattern 1: ReAct (Default)
The default behaviour. No configuration needed — the model decides when to call tools based on context:
pi "Fix the failing tests in src/auth/"Pattern 2: Plan-and-Execute
pi "Write a TODO.md plan for refactoring the payment module to Stripe v3. Wait for approval before editing."Pi intentionally does not ship a built-in plan mode. The native pattern is a file-backed plan (TODO.md, PLAN.md, issue text), or a project extension/package that implements the plan workflow you prefer.
Pattern 3: Multi-Agent (Orchestrator + Specialists)
Pi intentionally does not ship built-in sub-agents either. Use pi --print subprocesses, tmux panes, or an extension/package that implements specialist routing:
# agents/security-reviewer.md
---
name: security-reviewer
model: claude-sonnet-4-20250514
tools: [read, grep, find]
---
You are a security specialist. Review code for OWASP Top 10 vulnerabilities.Pattern 4: Reflection
Have a specialist agent review the primary agent's output before presenting it:
pi "Implement the feature, then run a second read-only review pass before summarizing."Pattern 5: Dynamic Tool Loading
When you have 50+ tools, load them progressively to avoid accuracy degradation:
pi.on("resources_discover", async () => {
// Only load tools relevant to current context
const packageJson = await readFile("package.json");
if (packageJson.includes("prisma")) {
pi.registerTool(prismaQueryTool);
}
});The OpenClaw Story: From Weekend Hack to 250K Stars
OpenClaw began as a "weekend hack" by Austrian developer Peter Steinberger. The concept: a personal AI assistant that runs on your own devices and answers on the channels you already use — WhatsApp, Telegram, Slack, Discord, Google Chat, Signal, iMessage, IRC, Microsoft Teams, Matrix, LINE, and more.
The architecture is straightforward: OpenClaw is a messaging gateway that uses Pi's createAgentSession() SDK to embed a full coding agent. Each channel gets its own isolated session. Docker sandboxing ensures agent code runs safely. Scheduled events enable cron-like triggers.
Why Pi Made OpenClaw Possible
- SDK mode: Pi embeds as a library, not a subprocess — full lifecycle control
- Provider agnosticism: Users choose their LLM (Claude, GPT, Gemini, local models via Ollama)
- Extension system: OpenClaw adds custom extensions for platform-specific features
- Session persistence: JSONL tree format means conversations survive restarts
- Minimal footprint: Pi's tiny core means fast startup and low memory usage
The Ollama Integration
ollama launch pi
ollama launch pi --config
ollama launch pi --model qwen3.5:cloud
pi install npm:@ollama/pi-web-searchOllama's Pi integration is now the cleanest local-model entry point: it installs Pi, configures Ollama as a provider, includes web tools, and drops you into an interactive session. Ollama's docs also call out @ollama/pi-web-search for web search/fetch tools and pi-autoresearch for autonomous experiment loops that optimize measurable targets such as test speed, bundle size, build time, training loss, or Lighthouse scores.
The TUI: Retained Mode vs Immediate Mode
Pi's terminal UI (pi-tui) makes a fundamental architectural choice that differs from every other coding agent:
The retained mode approach means Pi's TUI never flickers. Components persist across frames, cache their rendered output, and only re-render what changed. This is the same differential rendering model used by React — but for the terminal.
Extensions have full access to the component system. You can build interactive UIs — progress bars, tables, selection menus, syntax-highlighted code blocks — that integrate seamlessly with the agent output.
The 7 Failure Modes of Agents (and Pi's Solutions)
Context Economics: Why Every Token Matters
The chart illustrates why Pi's minimal approach wins economically. When your harness consumes 15,000 tokens before the user's first message, you are paying for that overhead on every single API call. Over a long session with hundreds of turns, the cumulative cost of a bloated system prompt is enormous.
Pi's approach: ~1,000 tokens for system prompt + tools. The remaining budget is yours.
The "Serious Work" Pi Configuration
If Pi is your daily coding agent, do not run it as an empty global CLI. Treat it like part of the repository. The point is not to make Pi heavier; the point is to make the agent's contract explicit, versioned, and reviewable.
Step 1: Install and Choose the Provider Path
npm install -g @mariozechner/pi-coding-agent
pi /loginUse /login when you want subscription/OAuth-backed providers such as Claude, ChatGPT/Codex, Copilot, Gemini CLI, or Antigravity. Use API keys when you want direct billing and reproducible provider credentials:
export ANTHROPIC_API_KEY=sk-ant-...
export OPENAI_API_KEY=sk-...
export DEEPSEEK_API_KEY=sk-...For local or cloud Ollama models, the clean path is now:
ollama launch pi
ollama launch pi --model qwen3.5:cloudOllama's integration installs Pi, configures the provider, adds web tools, and opens an interactive session. If you need manual control, define the provider in ~/.pi/agent/models.json and set defaultProvider / defaultModel in settings.
Step 2: Put Agent Rules in AGENTS.md
# Agent Contract
## Project
- Next.js, TypeScript, Tailwind CSS, PostgreSQL.
- Production deploys through Vercel.
- Never modify secrets, billing, DNS, auth providers, or database migrations without explicit approval.
## Commands
- Typecheck: npm run typecheck
- Lint: npm run lint
- Tests: npm test
- Build: npm run build
## Working Rules
- Read existing patterns before editing.
- Prefer small patches.
- Do not revert unrelated user changes.
- Before finalizing, report changed files and verification results.This file matters more than clever prompts. Pi loads AGENTS.md from global, parent, and project locations, so you can keep personal rules globally and repository rules locally.
Step 3: Add .pi/settings.json
{
"defaultProvider": "anthropic",
"defaultModel": "claude-sonnet-4-20250514",
"defaultThinkingLevel": "medium",
"enabledModels": [
"claude-*",
"openai/gpt-*",
"deepseek/*",
"ollama/*"
],
"compaction": {
"enabled": true,
"reserveTokens": 16384,
Do not copy the model names blindly; use pi --list-models and adapt them to the providers you actually use. The important part is the structure: default model, scoped cycling, compaction reserve, retry policy, project packages, and a clear telemetry choice.
Step 4: Install the Right Packages
pi install npm:pi-skills -l
pi install npm:@ollama/pi-web-search -l
pi list
pi configUse project-local installs (-l) when the package is part of the repository workflow. Use global installs for personal preferences. Pin packages when the workflow must be stable:
pi install git:github.com/user/repo@v1.2.0 -lThe security rule is simple: Pi packages can run code with your permissions. Review third-party packages before installing them, especially extensions.
Step 5: Add Skills for Deep Work
.pi/skills/
code-review/SKILL.md
release-check/SKILL.md
incident-response/SKILL.mdSkills are the right place for workflows that are too large for AGENTS.md: review checklists, deployment procedures, data-migration playbooks, SEO audits, browser-testing procedures, PDF extraction, or benchmark protocols. The model sees only the skill name and description until it needs the full instructions, which keeps the context window clean.
Step 6: Add One Safety Extension
// .pi/extensions/safety.ts
import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
export default function (pi: ExtensionAPI) {
pi.on("tool_call", async (event, ctx) => {
if (event.toolName !== "bash") return;
const command = String(event.input.command ?? "");
const dangerous
This is the Pi philosophy in code. Instead of waiting for the core tool to ship your preferred permission system, you implement the policy that matches your repo.
Step 7: Use the Right Mode for the Job
# Daily development
pi
# Continue latest session
pi -c
# Read-only audit
pi --tools read,grep,find,ls -p "Find deployment risks in this repository."
# Scriptable one-shot task
cat diff.txt | pi -p "Write a focused PR review."
# Integration mode for editors, dashboards, or bots
pi --mode rpcMy current recommendation:
| Workload | Pi setup |
| --- | --- |
| Architecture and hard debugging | Strong reasoning model, --thinking high, full tools |
| Cheap repetitive edits | Faster model, normal thinking, scoped file instructions |
| Security review | Read-only tool allowlist first, then explicit edit permission |
| Documentation and SEO | Skill-backed workflow plus browser/search extension |
| Local/private work | Ollama provider, web-search package only when needed |
| CI automation | pi -p or JSON/RPC mode with narrow tools |
The "clamorous" setup is not one magic plugin. It is a layered system: stable project instructions, reproducible settings, explicit model routing, audited packages, on-demand skills, and small extensions for the things your team actually cares about.
Why Open Source, Stripped to Basics, Wins
The lesson of Pi is not that minimalism is always better. It is that minimalism in the right places — the system prompt, the tool set, the core loop — creates space for maximalism where it matters: in the user's control over context, extensions, and workflow.
Claude Code is an excellent product. Cursor is an excellent product. But they are products — designed for the average user, optimised for the common case. Pi is a toolkit — designed for developers who want to understand and control every token that enters their agent's context window.
The evidence speaks for itself, updated against the public project state on April 27, 2026:
- 40,800+ GitHub stars on the core repo
- 4,800+ forks on the same repository
- 250,000+ stars on OpenClaw (built on Pi's SDK)
- v0.70.2 visible as the latest GitHub release during this update
- DeepSeek provider support for V4 Flash/Pro through
DEEPSEEK_API_KEY - Ollama integration making it a single-command install
- Pi packages for extensions, skills, prompt templates, and themes
- Agent Skills compatibility establishing a cross-agent skill standard
- RPC and SDK modes for building editors, dashboards, bots, and custom agent products on top of the same runtime
The next time you fight with a coding agent that is doing something unexpected — injecting content you cannot see, calling tools you did not ask for, consuming context on features you do not use — remember that there is an alternative. One that trusts the model, trusts the developer, and gets out of the way.
That alternative is Pi. And it is proving that in the age of AI agents, the best framework is the one that barely exists.
Pi is open source under the MIT license. Repository: badlogic/pi-mono. Official site: pi.dev.
OpenClaw: openclaw/openclaw. Armin Ronacher's analysis: Pi: The Minimal Agent Within OpenClaw.
Primary update sources: Pi official site, Pi README, extensions docs, skills docs, packages docs, settings docs, GitHub release v0.70.2, GitHub release v0.70.1, GitHub release v0.70.0, and Ollama's Pi integration.