What Is the Pi Coding Agent? Setup, MCP, Extensions, Which Models It Works With and Is It Free

You type pi in a project folder and give it work in plain language; Pi reads and edits files, runs commands and shows every step on screen. It's an open-source (MIT) terminal coding agent from Earendil Inc.; it has no model of its own: with the /login command you connect a provider's API key (for Claude, an Anthropic Console key), a ChatGPT or GitHub Copilot sign-in, or a local model. Anthropic's rules don't allow a Claude subscription to be used in third-party apps. The software is free; model fees go to the provider you connect. With version 1.0, released on October 1, 2026, MCP support became built in; it's extended with extensions, skills and packages. The interface is in English; Turkish replies depend on the model you choose.

What it does: Open-source terminal coding agent that shows every step
Type: Terminal coding agent, open source
Model: No model of its own; API key, sign-in or local model
Where: macOS, Linux, Windows (terminal)
Approval: Doesn't ask before each tool call
Latest release: 1.4.0 (21.10.2026)
Price: Software is free (MIT); model fees are separate

What is Pi and what does it do?

You want an AI agent to handle repetitive work in a software project (editing files, debugging, running commands, questions about the repo), but you want to decide which model to use and how the agent works. Pi is an agent harness built for exactly that: the program that runs the model, gives it tools for reading files, editing and running commands, and manages the conversation. Its official description is "a minimal, extensible agent harness you can adapt to your own needs".

Code and file work in plain languageWhat you get: File changes and command output; every step is visible on screenNeeds a separate setup You choose the model: key, sign-in or localWhat you get: Selected model; switch with /modelNeeds a connection Connecting an MCP serverWhat you get: The server's tools in the agentNeeds a separate setup

You type pi in a folderYou start it in the project folder it will work in; it finds the files and instruction files from there.

You describe the job in plain languageYou reference a file with @ and run a command with !.

You see every stepIt shows the files it reads, searches, commands and edits on screen; you can change direction while it works.

Pi doesn't ask for approval before each tool call; for important work, use version control or a backup.

Pi is kept small on purpose: subagents, plan mode, permission dialogs and to-do lists aren't built in. If you need them, you install an extension or ask Pi to write the extension. Who it's for: developers who are comfortable in the terminal and want to choose their own model and provider, and teams that want to adapt the agent to their own workflow. Who it's not for: people who don't use the terminal and want an agent that moves step by step through approval dialogs.

Sources: pi.dev home page ("What we didn't build"), README, Quickstart (October 29, 2026).

How do you install Pi? macOS, Linux, Windows

You don't need to create an account; you install Pi and connect it to a model provider. The commands are taken verbatim from the official README and Quickstart. The official installer pins every dependency to a fixed version and installs Node.js too if needed; the npm route requires Node.js 22.19 or newer and doesn't pin sub-dependencies.

Official installer› curl -fsSL https://pi.dev/install.sh | sh

To update later, pi update.

PowerShell› powershell -c "irm https://pi.dev/install.ps1 | iex"

Pi looks for Git Bash first to run commands; according to the official docs, installing Git for Windows is enough for most Windows users. If your files are on the Linux side, you can run Pi inside WSL.

Install a specific version› npm install -g --ignore-scripts @earendil-works/pi-coding-agent@1.4.0

The README's command has no version: npm install -g --ignore-scripts @earendil-works/pi-coding-agent; here it's pinned to the latest release as of October 29, 2026 (1.4.0, October 21, 2026). Node.js 22.19 or newer is required. The unscoped pi-coding-agent name on npm is only a name reservation, not the real package.

Latest stable release› nix profile add github:earendil-works/pi/stable

To pin a version, use a tag such as github:earendil-works/pi/v1.0.0; a Nix install is updated with nix profile upgrade pi, not pi update.

Check that it's installed: pi --version prints the version number.
Start it in the project folder: Go to the folder with cd and type pi.
Connect the model: Inside Pi, type /login and choose the provider; save an API key or use the provider's sign-in (for Claude, an Anthropic API key). For another model, /model.

Sources: README, Quickstart, Windows Setup, npm registry (October 29, 2026). The official docs have a separate Termux setup page for Android.

How do you use Pi? What you type, what you get

When giving Pi a job, you reference a file with @ (a search opens as you type), and you prefix a short command with ! to add its output to the conversation. The two requests below come from the examples in the official Quickstart; the results are described only as far as the docs describe them.

To-do list from meeting notes"Summarize @meeting-notes.md and save the action items to action-items.md."What you get: Pi reads the file, writes a summary in the chat and saves the action items to a new action-items.md file. The read and write steps are visible on screen; when it's done, you open the file and check it. You can also write the request in Turkish; the reply language depends on the model you choose.

Getting to know a repo"Explain how this repository is structured and how to run its checks."What you get: Pi scans the folder, explains the main folders and files, and tells you which command runs the tests or checks. Since the request only asks for an explanation, the expected output is a written explanation; every read and edit Pi makes is visible on screen.

Comparing two tables"Compare @previous.csv with @current.csv and summarize the important changes."What you get: a written summary of the important differences between the two CSV files.

Add a command's output to the conversation› !git status

Changing direction while it works: while Pi is working, a message you send with Enter steers the next reply once the current reply and tool calls finish; Alt+Enter queues it as the next request, waiting until the job is done. Sessions: Pi saves every session; pi --continue returns to the last session, and /tree lets you go to an earlier message and branch from there. /export writes the session as HTML or JSONL. /share uploads the session: to your Radius organization if you're signed in to Radius, otherwise to a secret gist via the GitHub CLI; before sharing, check whether the session contains keys or file contents.

From scripts and other programs

Pi has four modes: the full-screen terminal interface, one-shot output for scripts (print/JSON), RPC for use from other languages, and a TypeScript SDK to embed it in your own app.

One-shot task from a script, events as JSONL› pi --mode json "Inspect this repository" > events.jsonl

Sources: Quickstart, Use Pi in the terminal, Sessions, Command Line docs and pi.dev (October 29, 2026).

Which models does Pi work with? Providers and ways to connect

Pi has no model of its own. A provider is the service or account through which Pi reaches the model; the model is the AI that produces the replies. The official page says "15+ providers, hundreds of models"; the table in the providers doc is longer than that. The current model list, context limits and prices are in the official catalog (pi.dev/models); Pi can refresh this catalog at startup.

What you have	How to connect	Examples in the official docs
Provider sign-in	Browser sign-in with `/login` (OAuth)	OpenAI (Sign in with ChatGPT), GitHub Copilot; OpenRouter also creates a key via sign-in. The Pi docs also list Claude Pro/Max sign-in, but Anthropic's rules don't allow a Claude subscription to be used in third-party apps: for Claude, use the API key row
An API key	Save it with `/login` or use an environment variable	Anthropic, OpenAI, Google Gemini, Mistral, Groq, Cerebras, xAI, DeepSeek, OpenRouter, Hugging Face, Together AI, Fireworks, Meta, MiniMax, Kimi For Coding, NVIDIA NIM and others
Cloud account	The cloud's own credentials	Amazon Bedrock, Google Vertex AI, Azure OpenAI, Cloudflare Workers AI and AI Gateway
Local model	llama.cpp router or models.json	llama.cpp (direct), Ollama, LM Studio, vLLM, SGLang

Which should you pick? If you'll use Claude models, you use an Anthropic API key (Claude Console) or a supported cloud provider; you pay for what you use. The Pi docs offer ChatGPT or Copilot sign-in; before using that sign-in, check that provider's terms of use. With other providers, too, you save an API key. If you don't want your code to leave your computer, you connect a local model; speed and quality depend on your hardware. Within a session you switch models with /model (or Ctrl+L), set the selected model's thinking level with /thinking, and Ctrl+P cycles through favorite models. The moment you switch models, usage rights and fees switch to that provider's terms.

~/.pi/agent/models.json for connecting Ollama (official example)

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

According to Anthropic's Claude Code legal document, Claude Free, Pro and Max sign-in is for Claude Code and Anthropic's own apps; third-party apps aren't allowed to offer Claude.ai sign-in. For Claude models in Pi, use an Anthropic API key (Claude Console) or a supported cloud provider. With ChatGPT or Copilot sign-in, that provider's terms of use and limits apply.

Checked on October 29, 2026. Sources: pi.dev, the Providers and Choose a Model docs, and the "OAuth Providers" list in the pi-ai README. Earendil's own model gateway, Radius, can also be added as a provider; the docs describe it as "early alpha" and give no price.

Does Pi support MCP? Installing extensions, skills and packages

MCP (Model Context Protocol) is a common connection format that lets an AI use a service or tool (file system, document search, database). Pi used to leave MCP out on purpose; with version 1.0 on October 1, 2026, MCP support became built in. Pi connects to local (stdio) and remote (streamable HTTP) servers; the older SSE transport isn't supported.

Add a local MCP server, check it, start Pi

› pi mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem .
pi mcp list
pi

What you get: when Pi opens, this server's tools (here, file operations in your current folder) become available. With the default codemode exposure, the tools aren't introduced to the model one by one; the model looks them up and calls them through a codemode script. To make tools you use often directly visible, set exposure: direct in the config. The command adds the server at the user level; to add it only to this project, use --local. Inside a session, /mcp shows the connections and turns servers on and off.

What you need	The Pi equivalent
Instructions that always apply in a folder	AGENTS.md file
A reusable request from the `/` menu	Prompt template (Markdown file)
Instructions and helper files for a specific job	Skill (SKILL.md folder; Agent Skills format)
A new tool, command or event behavior	Extension (TypeScript module)
Sharing several of these together	Pi package (npm or git)

Installing a version-pinned package from npm (official example format)› pi install npm:@example/pi-tools@1.0.0

Having Pi write the extension itself"Write me a Pi extension that combines commit and push into a single command; show me the changes first, and commit only if I approve."The demo on pi.dev has Pi write exactly this kind of workflow extension. Pi writes the extension; it's loaded with /reload. The approval step isn't built into Pi; it's written inside the extension.

Extensions and packages run with the same operating system permissions as Pi; they can see your prompts, files and credentials. Don't install a package whose source you haven't read.

Sources: MCP Servers, Packages, Extensions, Skills docs, Quickstart ("Choose how to customize Pi" table), Pi 1.0 announcement (October 29, 2026). Subagents and plan mode aren't built in; pi.dev suggests doing these with an extension, a package, or by opening separate Pi sessions with tmux.

Is Pi free?

Yes, the Pi software is free and open source (MIT license); Pi has no paid plan of its own. The money goes to the model you connect: with ChatGPT or Copilot sign-in, that plan's fee and limits; with an API key, the provider's pay-as-you-go price; with a local model, only your own hardware. The /session command shows the session's token usage and cost.

Allowed

Using, copying, modifying and distributing it, including commercially (MIT)

Not allowed

Removing the copyright and license notice from copies
The software is provided "as is"; the developer gives no warranty

Source: LICENSE (MIT, copyright Mario Zechner), Pi 1.0 announcement ("Both are MIT licensed"), Use Pi in the terminal (October 29, 2026). There is no price in Turkish lira; fees are only on the provider side. This is not legal advice.

Does Pi work in Turkish?

InterfaceNo	The terminal interface and commands are in English.
Turkish requests and repliesUnclear	You can write requests in Turkish; the language and quality of the reply depend on the model you connect. The official sources don't mention Turkish.
Turkish documentationNo	The docs are in English.

Is Pi safe? What does it do to my files, and where does my data go?

No permission system

README: Pi has no built-in permission system restricting file, process, network or credential access; it runs with the permissions of the user who starts it and doesn't ask before each tool call. The docs recommend running Pi inside a container or virtual machine for untrusted or unattended work.

Where your code goes

Files Pi reads and your requests go to the provider you connect, and its data rules apply. If you connect a local model, nothing leaves your computer.

Credentials

Sign-in tokens and API keys are stored in ~/.pi/agent/auth.json; the docs say to keep this file private and out of repos. If you don't want to write the key to disk, you can use an environment variable or a password manager command.

Telemetry

Install and update pings are on by default (anonymous; setting name enableInstallTelemetry). Turn them off with PI_TELEMETRY=0. Analytics sharing (enableAnalytics) is off by default.

Project trust

A folder's .pi settings, MCP servers and extensions aren't loaded until you trust that project. But instruction files such as AGENTS.md and CLAUDE.md are read in every case; the docs say to treat them as untrusted input.

Files, comments and command output in the folder can steer the model (prompt injection). In an unfamiliar repo, run Pi in a container and give it only the files and keys it needs.

Sources: README ("Permissions & Containerization"), Run Pi safely, Settings, Environment variables, Providers (October 29, 2026). This is not a security audit; vulnerabilities are reported through the repo's SECURITY.md.

Common problems and fixes

What happens	What to do
The model you want isn't in the `/model` list	The picker shows only models from providers you've signed in to. First connect that provider with `/login`; to refresh the catalog, `pi update --models`.
Commands don't work on Windows	Pi looks for Git Bash first for commands. Install Git for Windows or run Pi inside WSL. To check, type `!printf 'Bash is working\n'` in Pi.
The project's .pi settings or MCP servers didn't load	Project trust hasn't been granted. Pi asks at startup; you can save your choice with `/trust`.
On a remote server, the `/login` browser callback doesn't work	According to the docs, when prompted you paste the final redirect URL or the authorization code into Pi.
I added an MCP server from outside but it doesn't show up	Run `/reload` inside the session; check the status with `/mcp`.

Sources: Choose a Model, Windows Setup, Run Pi safely, Providers, MCP Servers (October 29, 2026).

How do you uninstall Pi?

› npm uninstall -g @earendil-works/pi-coding-agent

Run the installer again (curl -fsSL https://pi.dev/install.sh | sh) and choose the Uninstall Pi option.

› nix profile remove pi

None of these methods deletes the ~/.pi/agent/ folder: settings, saved keys and tokens (auth.json), sessions and installed packages stay there. If you want a full cleanup, delete this folder yourself; you can also revoke the provider sign-in authorization separately on the provider's side (/logout doesn't revoke the authorization at the provider).

Pi, Claude Code or OpenCode?

The Pi row comes from this page's official sources; the other rows summarize those tools' own guides. This is not a ranking.

Frequently asked questions

Does Pi support MCP?

Yes. MCP support has been built in since version 1.0 on October 1, 2026. You add local and remote (streamable HTTP) servers with the pi mcp add command; the older SSE format isn't supported.

What is Pi (pi.dev)?

An open-source AI coding agent from Earendil Inc. that runs in the terminal. It reads and edits files and runs commands in your project folder; it has no model of its own, and you connect the provider.

Pi or Claude Code?

Pi is open source and provider-independent: you can connect Claude, another provider or a local model. Claude Code is Anthropic's own tool and works with a Claude account. Pi is kept small on purpose; features such as subagents and plan mode come via extensions.

How do you install extensions and skills in Pi?

Extensions, skills, prompt templates and themes are installed as packages from npm or git with the pi install command. You can also ask Pi to write the extension itself and load it with /reload. Packages run with the same permissions as Pi, so don't install one without reading its source.

How do you install Pi?

On macOS and Linux, curl -fsSL https://pi.dev/install.sh | sh; on Windows, the PowerShell installer; or, with Node.js 22.19 or later, npm install -g --ignore-scripts @earendil-works/pi-coding-agent. Then type pi in your project folder and connect a model with /login.

Does Pi work with Ollama?

Yes. Compatible servers such as Ollama, LM Studio and vLLM are added to the models.json file; there's also a direct connection with llama.cpp. There's no model fee; speed depends on your hardware.

Does Pi have subagents?

Not built in. The official page suggests opening separate Pi sessions with tmux, writing an extension, or installing a package that does it.

Is Pi free?

The software is free and MIT-licensed; Pi has no paid plan. The fee goes to the model you connect: with ChatGPT or Copilot sign-in, that plan's fee; with an API key, the provider's price; with a local model, only your hardware.

Related guides

Cline

Cloudflare Workers AI

Sources

Not clear in the official sources: Turkish reply quality (depends on the connected model; the official sources don't mention Turkish) · the price of the Radius gateway (early alpha). Each is covered in the relevant section along with what you can do.