Pi Coding Agent: The Minimal, Extensible AI Agent Stack for Serious Developers

The best coding agents of 2026 are not 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 read in an afternoon, then let developers build the workflow they actually need on top of it.

Pi is a coding agent framework 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 — past React, to the top of GitHub's all-time leaderboard.

What follows is the full tour of Pi as it exists right 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 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. Since the first version of this article, one thing has changed for good: Pi stopped being "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 sketches 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 at roughly 40.8k stars and 4.8k forks. Those numbers will keep moving. The pattern behind them matters more: Pi is shipping fast, and the changelog shows a core that is hardening, not bloating.

What Changed Recently

Read the release stream and a direction emerges:

• 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 got 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 via DEEPSEEK_API_KEY.
• The login and model UX keeps improving. The v0.70 stream adds fuzzy-search provider login, clearer auth-source labels, refreshed default model selection, and better warnings that send users to /login when a model or credential is missing.
• Long-running inference is easier to control. Provider request timeout/retry controls now live under — exactly what you need for local inference, overloaded providers, and long reasoning runs.

The practical reading: Pi is not accumulating 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-pro or deepseek-v4-flash, Pi now treats 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 — especially for local models, cloud models under load, and long-context requests.
• Model selection becomes less fragile. Searchable /login, provider labels, and refreshed model defaults sand down the operational friction that usually makes multi-provider agents a chore.
• Terminal behavior becomes more conservative. Progress reporting is now opt-in — the correct default for terminals, multiplexers, remote shells, and recorded sessions.

The through-line is hard to miss: Pi keeps adding control surfaces, not hidden automation. Which is exactly what you want from a runtime that touches your codebase.

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, so you could never know what the model actually saw.
• Tool proliferation: dozens of overlapping tools competed for the model's attention, burning context budget on descriptions alone.

His thesis: strip a coding agent down to its absolute minimum — a tiny system prompt, four tools, full context transparency — and 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 backed him up. Pi with Claude Opus held its own 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 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 tells the story on its own. Every token a harness spends on itself is a token the model cannot spend on your code — and a 10,000-token system prompt spends a lot of them. 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.

None of this is accidental. Each package stands on its own. 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 compose; nothing is monolithic.

pi-ai: The Unified LLM API

The foundation of everything. pi-ai maps 15+ LLM providers to a single, unified interface — built on one blunt observation:

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 signature trick: sessions can span multiple LLM providers in the same conversation. Switch from Claude to GPT mid-session and the entire context — thinking traces included — 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 provider switching with extra steps — 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 — Claude Code, OpenClaw, Pi itself — implements the ReAct (Reasoning + Acting) pattern, introduced by Yao et al. at Princeton/Google in 2022. The insight: LLMs perform significantly better when they can reason, act, observe, and reason again, rather than answering in a single pass.

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, you 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 lands in the next one. In practice the distinction is worth gold: it separates "stop, do this instead" from "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:

1. Frontier models already know these tools. They have been RL-trained extensively on coding agent scenarios.
2. Every additional tool competes for context space. Tool descriptions are expensive — they ride along in every single request.
3. Bash is universal. grep -r, find ., git log — commands the model knows like the back of its hand.

Optional Read-Only Tools

For safe exploration sessions (say, onboarding to a new codebase), Pi offers read-only mode:

pi --tools read,grep,find,ls

This disables write, edit, and bash — the agent can explore but cannot touch 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. That gives you a tree, and a tree gives you branching: return to any previous point and continue from there, creating a new branch while every previous branch survives 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 handles 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 get replaced by a summary generated by a cheap model (Claude Haiku, for instance). Sessions become effectively unlimited, with no quality cliff:

The compaction threshold is configurable — and the summary model can differ from the primary model. Haiku for summaries, Opus for reasoning is the pairing that costs pennies and gives up nothing.

The 4 Operating Modes

All four modes share a single abstraction: AgentSession. They differ only in their I/O layer.

SDK Mode: How OpenClaw Uses Pi

OpenClaw — the 250K+ star personal AI assistant — runs on Pi's SDK mode. It does not spawn Pi as a subprocess. It imports and instantiates Pi directly, with 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 it went viral because the engine underneath was solid enough to carry real-world, multi-channel workloads.

The Extension System

Extensions are TypeScript modules loaded by jiti — a runtime TypeScript/ESM transpiler that needs no build step. That enables hot-reload: edit the .ts file, type /reload, and your changes are live.

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

Here 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:

1. You describe what you want: "I need a /deploy command that runs our staging pipeline"
2. Pi writes the extension as a .ts file
3. You type /reload
4. Pi tests the new command
5. If it fails, Pi reads the error, fixes the code, reloads, and retries

Armin Ronacher (creator of Flask and Jinja2) called this "software that is malleable like clay." Every one of his Pi extensions — /answer, /todos, /review, /files — was written by Pi itself, not by Armin. He described the requirements, pointed the agent at examples, and Pi implemented them on its own.

The System Prompt: ~100 Tokens

This is the actual Pi system prompt, reproduced from source. Hold it up against 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 goes to:

The hierarchy loads in this order:

1. System prompt (~100 tokens)
2. Tool definitions (~900 tokens)
3. AGENTS.md files (project-specific context, user-controlled)
4. Skills (progressive disclosure — loaded on demand)
5. Conversation history (the bulk of the context)

You control the majority of the context budget through AGENTS.md. That is Claude Code inverted: there, the harness controls most of the context and you get 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 references

Skills use progressive disclosure: their full content enters the context only when triggered, never at session start. The baseline stays lean; the deep functionality stays one trigger away.

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 deliberately ships no 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 whatever plan workflow you prefer.

Pattern 3: Multi-Agent (Orchestrator + Specialists)

Pi deliberately ships no 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 keeps agent code contained. Scheduled events enable cron-like triggers.

Why Pi Made OpenClaw Possible

1. SDK mode: Pi embeds as a library, not a subprocess — full lifecycle control
2. Provider agnosticism: users choose their LLM (Claude, GPT, Gemini, local models via Ollama)
3. Extension system: OpenClaw adds custom extensions for platform-specific features
4. Session persistence: the JSONL tree format means conversations survive restarts
5. 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-search

Ollama'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 an architectural choice no other coding agent makes:

Retained mode means Pi's TUI never flickers. Components persist across frames, cache their rendered output, and only re-render what changed. It is the same differential rendering model React uses — pointed at the terminal.

Extensions get full access to the component system. You can build interactive UIs — progress bars, tables, selection menus, syntax-highlighted code blocks — that sit seamlessly inside the agent output.

The 7 Failure Modes of Agents (and Pi's Solutions)

Context Economics: Why Every Token Matters

The chart shows where the money goes. A harness that consumes 15,000 tokens before your first message charges you that overhead on every single API call — and over a session with hundreds of turns, a bloated system prompt turns into a real line item.

Pi's approach: ~1,000 tokens for system prompt plus 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 /login

Use /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:cloud

Ollama'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 personal rules can live globally while repository rules travel with the repo.

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; run pi --list-models and adapt them to the providers you actually use. What matters is the structure: default model, scoped cycling, compaction reserve, retry policy, project packages, and an explicit 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 config

Use project-local installs (-l) when the package belongs to 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 -l

The security rule is one line: Pi packages run code with your permissions. Review third-party packages before installing them — extensions especially.

Step 5: Add Skills for Deep Work

.pi/skills/
  code-review/SKILL.md
  release-check/SKILL.md
  incident-response/SKILL.md

Skills are the right home for workflows 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 — the context window stays 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 your repo actually needs. Twenty lines, done.

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 rpc

My 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 serious 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 always wins. It is that minimalism in the right places — the system prompt, the tool set, the core loop — creates space for maximalism where it counts: in your 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 — built for developers who want to understand and control every token that enters their agent's context window.

The scoreboard, as of 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 a coding agent that is doing something unexpected — injecting content you cannot see, calling tools you did not ask for, spending context on features you never use — remember 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 making a strong case 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.