Pi: The Pinnacle of Simplicity – A Minimalist Agent Surpassing Codex and Claude Code. A Comprehensive Guide to Master It All in One Article

https://t.co/j8MX7weqKu

Pi: The Pinnacle of Simplicity – A Minimalist Agent Surpassing Codex and Claude Code. A Comprehensive Guide to Master It All in One Article

Video Version: https://youtu.be/HhZcnM9tR7s

Pi is an incredibly popular AI Agent recently, and it can be described in four words: pure simplicity. Pi has only four basic tools, and its system prompt is merely 1,000 tokens. Saying “hello” in Pi only uses 1,100 upload tokens, consuming just 0.4% of the context window. In contrast, a simple greeting in Codex uses 18,000 tokens, consuming 7% of the context window without doing anything.

Pi’s extreme minimalism brings extreme efficiency gains. According to a benchmark test from Composio last month, Pi Agent completes coding tasks 1.5 to 2 times faster than other coding agents, and its task cost is also significantly lower than mainstream frameworks.

In terms of coding quality, the data service giant Databricks ran a benchmark test on one of its million-line codebases. The horizontal axis in the graph represents task cost, and the vertical axis represents the task pass rate, which is code quality.

The red line demonstrates the agent-model combination with the highest task success rate at the same cost. We can see that Pi’s performance outperforms Claude Code and Codex in most scenarios. The highest point of code quality on the entire chart is the combination of Pi plus Claude Opus 4.8. This issue brings a complete tutorial for Pi Agent, primarily divided into the following 11 chapters, each interspersed with important knowledge, providing a detailed explanation of all of Pi’s features. Enough talk, let’s get started.

Pi Installation & Configuration

Let’s install Pi first. I’ll start with Windows, then Mac. Here, I’m using a brand-new Windows computer for testing. No preparation is needed to install Pi. Right-click on the desktop, open a terminal, and open the Windows PowerShell console.

Then we go to Pi’s official website, find this one-click installation command for PowerShell, copy it, paste it into the console, and press Enter.

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

Pi detects that the computer doesn’t have Node.js. Here I type y and press Enter to install Node.js first. At this step, press Enter again to install Pi itself. Pi uses Git Bash as its command-line environment. If Git isn’t installed on your computer, it will ask first. It’s recommended to input w to let Pi help you install Git on Windows first.

Okay, at this step, the Pi installation is complete. We need to close the current command-line window first, then right-click to reopen a terminal, input pi, and start Pi. If the dialog window displays successfully, our Pi is installed. Next, let’s look at the macOS installation. First, open the terminal, then go to Pi’s official website. Note that you should copy this curl command and paste it into the terminal to execute.

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

This way, Pi is also installed on Mac.

Model Configuration

Next, let’s configure the model for Pi. First, start Pi, come to this interface, then input the command /login.

There are two ways to configure the model: API key or model subscription. Here I’ll choose API key first. Pi supports over 40 model providers, covering virtually all common models on the market. Here I’ll use DeepSeek as an example. We can first input keywords to filter for DeepSeek, then press Enter.

Next, we go to DeepSeek’s official website, click on the API Open Platform, first ensure you have some credits, then click on API keys, click Create API key, and give it any name.

Then copy the newly generated API key, paste it into Pi, and press Enter. Say hello, and once a response is received, our DeepSeek model configuration is complete. The default model we’re using now is DeepSeek V4 Pro. We can input the command /model to switch models.

For example, here you can switch to DeepSeek V4 Flash. Use the shortcut Shift+Tab (same for Mac) to switch the model’s thinking intensity; you can choose based on the complexity of the task. Pressing Control+L (same for Mac) also quickly opens this model selector. Next, let’s see how to use a model subscription to connect a model to Pi Agent. Still input the command /login, and we choose “Sign in with account” above.

Then, using my OpenAI subscription as an example, I select OpenAI Codex, then choose the first option to log in via browser. Then a login window opens in the browser; here I log in to my OpenAI account. After logging in, we return to Pi, press the shortcut Control+L, and the ChatGPT models appear in the model list.

Basic Operations

Here I’ve created a new folder as a project folder. After entering it, right-click to open a terminal, input Pi to start it.

The Pi window displays the current folder, which is the project folder.

Subsequent instructions will have the code written into this project folder. “Use the React framework to make a pet grooming salon webpage.” If our instruction is multi-line and we want a line break, don’t press Enter here; pressing Enter sends it immediately. We can press Shift+Enter (same for Mac) to start a new line, then input the second line. Another way is to press the shortcut Control+G (same for Mac) to open a notepad; we can edit the prompt more conveniently in the notepad.

After editing, save it, close the notepad, and the prompt will synchronize into the window. For example, I’ve input 3 lines of prompt, press Enter to execute.

Pi completes the code writing. Let’s look at the bottom line of information first.

Here, the up arrow represents the input tokens for the entire session. A session is a continuous dialog record, documenting the entire working process of the AI’s multi-turn dialog. We can type /new in Pi to start a new session. In the new session, the AI has no past dialog history, and the context window is cleared. The down arrow represents output tokens; a total of 11,000 tokens were output. The capital R is Cache Read, meaning how many tokens in the entire session hit the cache. CH is Cache Hit Rate, the cache hit rate of the most recent request. Note that this cache hit rate is not for the entire session, but for the most recent AI call request. There is also an estimated cost for this conversation; the parentheses sub means subscription, indicating I’m using a ChatGPT subscription, so the preceding cost is for reference only. Finally, 4.6% means it’s currently using 4.6% of the model’s context window. Then after the slash is the model’s total context window; GPT-5.6’s total context window is 272k. auto is the context compression mechanism; auto means automatic compression. That is, when context usage reaches a threshold, Pi will automatically trigger a context compression.

Finally, it shows the model provider and the current model’s name. After the dot is the current model’s thinking intensity. After the code is written, it suggests we can use npm run dev to start it. The most convenient way here is to run the command directly in the current window. We type an exclamation mark !, then input the command npm run dev and press Enter. This way, our development server is started.

So the function of the exclamation mark is to temporarily run a command in the current dialog window. Using the exclamation mark to run commands, the AI can see both the results and the process of the command execution. If you don’t want the AI to see the commands we run, you can type two exclamation marks !! here, then input the command.

In this way, the input command is invisible to the AI. We can open this link to view the webpage developed by the AI for us. If we’re dissatisfied with any part, we can directly take a screenshot to communicate with the AI. For example, I don’t like the layout here, so I directly take a screenshot, go to Pi. For Windows, press Alt+V; for Mac, press Control+V to paste the screenshot.

Then I tell the AI that the number of floating cards is too small. Pi reads this image, and after a while, completes the modification. Now there are two more cards. Besides pasting screenshots, we can also use another way to communicate with the AI. That is to input @, and then we can select a certain code file. Here I select the src directory, then input / to select the main file. I tell the AI not to put all the code in one file, but to split it into modules. This way, through the @ file method, we completed this round of communication, and the AI helped us split the code into modules.

Command Appending

Next, I ask Pi to make the project a full-stack application, needing the booking information stored in a database. We see here the AI wants to use the Express framework for the backend, but I prefer using the Next.js framework. In this situation, in Pi, we don’t need to interrupt the AI’s execution; we can directly add hints to the AI in the dialog. I input in the dialog box that I need the Next.js framework, and use SQLite for the database. Then press Enter directly.

We see the new command we input is prefixed with “Steering”. Steering means to control or guide; its original English meaning is to steer the wheel. When we find that the AI misunderstood our intentions during execution, we should decisively use Steering to guide and intervene in the AI’s behavior. In Pi, when a user appends a command, it defaults to Steering. We see that after this Steering command is sent, the AI immediately changes its execution direction and starts installing Next.js-related dependencies for us.

Besides the default Steering guidance, Pi Agent provides another way to append commands, called Follow-up. Follow-up means to queue.

The biggest difference between Follow-up and Steering is that Follow-up does not affect the AI’s current round of work. Instead, it waits for the AI to complete all work in this round before the AI sees and executes the user’s next command. On Windows, using Follow-up requires modifying a configuration. We first right-click to open PowerShell settings, find this shortcut Alt+Enter under Operations, which makes PowerShell full-screen. First, delete this shortcut because it conflicts with Pi’s default Follow-up shortcut.

Then click Save in the bottom right corner. After deleting it, we return to Pi. Next, input another command, and after inputting, don’t press Enter; use Alt+Enter. The shortcut on Mac is Option+Enter. We see this command is prefixed with “Follow-up”, meaning it has entered the queue.

Follow-up commands need to wait for the AI to complete all work in this round before they can be processed. During the queuing process, we can also press the shortcut Alt+Up Arrow to retrieve this command for re-editing. For example, here I make some modifications, and after finishing, click Alt+Enter again to send it into the queue for queuing. After a while, the AI completes all work in this round, and then it can see and execute my latest command, which is to add a backend panel to view user bookings. In this example, we saw the two most classic ways to append commands in Pi Agent. One is Steering, guiding during execution; the other is Follow-up, letting commands queue up.

Here’s a brief supplement on the implementation principles of Pi’s Follow-up and Steering command appending. Pi’s core Agent Loop is a double-layered loop mechanism. Let’s look at the inner loop first. In the inner loop, Pi calls the large model, then calls tools based on the model’s instructions, returns the tool processing results to the model, and the model determines if the work is completed. If not completed, it enters the next cycle. There is a clever design here: when entering the next cycle, Pi injects the Steering message into the context.

This way, Pi can react in real-time to user commands. The Follow-up message, however, is in the outer loop and needs to wait for the inner loop processing to complete. That is, after Pi finishes its current work, it will also read the Follow-up message. At this point, if Pi finds there is a Follow-up message, it will start the outer loop and continue working.

Besides running Pi in interactive mode, Pi also provides a one-time non-interactive mode. Here we can input -p after the command, then fill in the instruction we want it to process in quotes. I ask Pi to check today’s weather and write a weather.txt file on the desktop. Press Enter. Pi will silently execute this requirement in the background; we can’t see the intermediate process. Once it finishes execution, it will output the results, and the weather file will also be written on the desktop. This non-interactive mode is particularly suitable for using Pi as a one-off CLI command.

Session Management & Conversation Tree

The unit of Pi Agent session management is the Session. For example, I have three conversations with the AI, asking it to add apple, banana, and orange to the fruit list. The complete history of these three conversations is one Session. Then I can input /new to create a new Session. In the new Session, I ask the AI to add eggplant, celery, and cabbage to the vegetable list. This way, we have two conversation histories, two Sessions.

When we close the window and want to continue working next time, we can input pi -c to continue from the most recent Session, which is the vegetable list one. Or we can input pi -r to choose a Session to continue from. For example, this time I choose the fruit Session, and we return to the fruit conversation history.

In Pi, each Session is not a purely linear structure but can be a tree structure. This is Pi’s special feature: the conversation tree. For example, I can go to the vegetable Session, input the command /tree to enter the conversation tree. Here I can select the node for “Add celery”, press Enter, then press Enter again. This returns the conversation to a previous historical state. We can create a branch for the conversation based on this historical state and try different approaches.

For example, this time I don’t want to add more vegetables; I want it to add seafood. Here the AI helps us create a new file and writes “mantis shrimp”. We can input /tree again to check.

We can see in the conversation tree that a timeline branch has been created on this conversation history. On one timeline, we continue adding vegetables; on the other timeline, we added seafood. If we draw this Session as a tree, it would look approximately like this.

Here we need to note that when we use the tree to backtrack conversation history, the already written code does not backtrack correspondingly. For example, I want to use this tree to backtrack the conversation history to the eggplant state and then remove the later mantis shrimp, celery, and cabbage from the code. When we use the tree for backtracking, we can only backtrack the conversation history, not the code. If we want to backtrack the code, we need to use it in conjunction with git.

Here I still input the /tree command, find the conversation record for “Add eggplant”, and press Enter. This way, we first backtrack the conversation history using the tree. Next, let’s backtrack the code using git. This code is already managed by git. If you’re not familiar with git working with AI, you can refer to this video. We find the commit for “Add eggplant”, then copy its commit ID.

Back in Pi, input !, then this command: git reset --hard, which forces the code back to the state of the “Add eggplant” commit. Press Enter.

Now we open the code to check. The code now only contains eggplant, no other vegetables. This way, we used git commands in conjunction with the conversation tree to roll back a piece of history from both the conversation record and code levels.

Here’s a补充 point: when we backtrack conversation history, Pi gives three options. The first is “No Summary”, which is a complete backtrack. The second is to “Summarize”, which means letting the AI summarize the part of the conversation history you discarded. The third is to “Tell AI how to summarize”. Let’s look at this image.

For example, now I want to backtrack from the cabbage conversation history to the eggplant one. If we choose “No Summary”, the AI completely discards the later conversation history. If we choose “Summarize”, the AI will summarize this conversation history on the current branch. After we complete the backtrack, the AI will have a general impression of the work processed in this past branch. Here’s one thing to note: when summarizing, the AI only summarizes the work on this branch; it won’t summarize other branches. That is, it won’t summarize the mantis shrimp conversation record. Let’s try it now. Currently on the cabbage conversation, I input /tree to expand the conversation tree. Now I want to backtrack to the eggplant conversation. Find the eggplant conversation, click Enter, then choose “Summarize” to summarize the conversation on the branch I’m backtracking. Press Enter.

This completes the summary; we can press Control+O to expand. We see only the summary for the branch I backtracked; the other branch, the mantis shrimp branch, is not summarized. Pi’s session management also has 3 important commands.

First is “Clone”. Clone means completely copying the current Session to become a new Session. For example, I’m currently in the vegetable Session and input /clone. This completely copies the current Session into a new Session. Then I can press Control+C twice to exit Pi, then input pi -r to see the current Sessions. We see the vegetable Session has been copied into two.

A similar command is /fork. Fork does not clone the entire tree but allows you to select a conversation node and base a new Session on that node. For example, I’m in the fruit Session, and I can select the banana node and fork it, creating a new Session. The forked new Session only carries the previous conversation history. Here I go to the fruit Session, input the command /fork, then select the banana conversation record and press Enter. We see a new Session is created, and it only has the previous conversation history.

The next command is /compact. This command is used to manually trigger context compression. For example, this is the Session for creating the pet grooming website at the beginning of the video. We see the percentage here is 18.1%, indicating what percentage of the model’s context space the historical conversation content is occupying. When context usage exceeds a threshold, Pi will automatically compress the conversation history, thereby freeing up more context space. Here we can also use the /compact command to manually compress. Pi will summarize and streamline the previous conversation history. We see the context usage drops from 18% to 10%. This can effectively improve the AI’s focus and reduce subsequent token consumption.

However, in the agent field, there is a general rule: clearing is better than compressing. Because too much history can interfere with the AI’s attention, so after we complete a round of tasks, the best way is to directly input /new to start a new Session. That is, starting a new dialog to clear the model’s context, which helps the AI focus all its attention on the new task, thereby improving task execution effectiveness.

Tool Design & Plugin Extensions

Pi is a minimalist agent with only four basic tools by default: Read File (Read), Write File (Write), Edit File (Edit), and Run Command (Bash). Pi’s design philosophy is to use the smallest set of tools to cover the vast majority of programming tasks. Actually, these four tools are already powerful enough, especially the Bash tool for running command lines, which is itself a powerful universal tool. For example, you can use Bash to call find to search for files, grep to search code, ls to list directories, etc.

Besides these four core tools, Pi also supports Agent Skills, and that’s it. Pi has no MCP, no SubAgent, no Plan Mode, no Todo, and no BTW. Pi’s design philosophy is that the smaller and cleaner the core, the better the model can perform. At the same time, it gives users the maximum freedom to assemble other capabilities. Just as this line on Pi’s homepage says: Let tools adapt to your workflow, not the other way around.

Pi provides very rich extension capabilities, mainly reflected in two aspects: one is plugins, and the other is Skills. In this chapter, we’ll look at how to extend various capabilities for Pi by configuring plugins.

Installing plugins for Pi is very simple. First, we go to Pi’s official website, then find this “packages” section, which is its plugin list.

Let’s look at a few important ones first. First is this pi-web-access, which gives Pi the ability to search the internet and makes it more convenient to extract web page information. Here is its one-click installation command; we copy it.

Still open the Windows console, paste the command, and press Enter. This installs the internet search plugin.

Then we start Pi. Here there’s an [Extensions] showing that we now have the internet search plugin. We can test it by asking about the weather in Qingdao. We see Pi calls the internet search capability, summarizes, and displays the result. A great thing about this plugin is that it’s zero-configuration; it integrates the Exa MCP service and doesn’t need any API key. Just install and use, very convenient.

If you want to uninstall a plugin in Pi, it’s also very easy. Just change “install” in the installation command to “uninstall”. This uninstalls the internet search plugin.

Let’s look at another plugin, pi-subagents. This plugin gives Pi the ability to run multiple sub-agents in parallel. We still copy the installation command.

We use the default installation command, which installs the plugin to Pi’s global directory. This means this plugin will apply to all projects. Each plugin we install actually adds a part of the system prompt. If some projects don’t need this plugin, it actually adds a burden to the model. So we have another installation method, which is to install this plugin only in my current project, i.e., the pi_test project, not globally. For project-level installation, we can add a space and -l after the command, where -l means local, then press Enter.

Here, go to the project directory to check. We see this plugin is installed under the .pi folder in the project directory.

So this plugin is now project-level, only applying to the current folder. We start Pi again. Because there’s a plugin in this directory, it asks me if I trust the current directory on first launch. I choose to trust.

Here we see our plugin is installed. We input /pi-subagents to call this plugin’s built-in skill.

I ask it to design 5 personal webpages in different styles. Press Enter. We see Pi starts 5 workers, meaning 5 sub-agents developing the page in parallel.

The 5 pages are of 5 different styles. This way, Pi uses 5 sub-agents to complete the work in parallel, including parallel review and fix, delivering 5 personal webpages. We can go to the directory to check the actual effect; it’s pretty good.

Pi does not have MCP functionality by default. We can install the pi-mcp-adapter plugin to give it MCP capabilities.

Here I still copy the installation command and paste it into the Windows console to execute. We can look at the plugin to see how to configure the MCP Server. It says it automatically reads the .mcp.json file. So I go to the project directory, create a new .mcp.json configuration file. Here I’m going to configure a Gaode Maps MCP. I copy this section.

Here the key needs to be replaced with the key applied for from the Gaode Maps official website. I applied for a key on the Maps Application Open Platform, copy it and paste it here. Good, the configuration is complete. Next, we start Pi. Here it shows the MCP Server is ready. Let’s test it; I ask it to check the public transportation route from Taipingjiao Park to Laoshan Yangkou. We see Pi can call the Gaode Maps MCP to find coordinate information and plan routes, etc. Pi outputs a complete route guide for us; the effect is quite good.

When I used Claude Code before, I often relied on a feature called BTW, short for “by the way”. BTW allows opening a side dialog while the AI is working. We can ask the AI some questions in this side dialog, which doesn’t interrupt the AI’s work. Pi does not have the BTW feature natively, but we can add this feature by configuring a plugin. Here I go to Pi’s packages again, then search for “btw” in the filter. If there are multiple plugins with the same name, it’s recommended to install the one with an earlier update time and higher download count. Here I choose the first one, still copy the installation command.

Open the Windows console, paste it, and press Enter. This completes the installation. Then we start Pi. Here I first ask the AI to investigate the functionality of this project. While the AI is working busily, I can open a side dialog, input /btw, then ask a technical question. For example, I ask it “What is Next.js?” and press Enter. Pi opens a sub-window to answer our question. We see we’re now in a side dialog; it won’t affect the AI’s work. We can continue asking questions in this window, or press Control+C to exit this sub-dialog and return to the main dialog. We see that our side question didn’t interfere with the main dialog; the main dialog is still continuing its work.

Let me introduce another feature I use every day: Plan Mode. We search for “plan” in the plugins, find the first one related to Plan Mode, and copy it.

Go to the console to execute it. Now Pi has plan mode. We start Pi. Here we input /plan-mode and press Enter. We see a “plan” marker below, indicating we’re now in plan mode. In plan mode, the AI doesn’t start working; instead, it first outputs a plan, which we can adjust and modify. Once the AI’s plan aligns with my requirements, I’ll turn off plan mode and let the AI start executing.

Let’s try it. I say, “Change the database to Supabase’s database.” We see Pi first generates a plan and writes it to a PLAN.md file. We can modify this plan. If we confirm these plans are correct, we can input the Plan Mode command again to turn off plan mode. Then input a command to confirm and implement the plan. Next, Pi starts formal development.

Another plugin to introduce is Pi Goal. Goal mode is also a feature that Codex and Claude Code both supported recently. You can input the /goal command and then give the AI a goal. You can have Pi execute work over multiple rounds towards a fixed goal until the final goal is achieved. Here we still copy the installation command and install the plugin in the Windows console.

Then we start Pi, input the command /goal. Here I give it a relatively big goal: make a tank battle game in HTML, start it after writing, play-test it, then output test conclusions and remake a version. I need multiple iterations, and the final effect should be as close as possible to the NES tank battle game. We see now Pi starts this goal mode and starts writing the game. Pi iterated a total of three times and completed the game development. We can see its historical iteration process in the iterations section. Then we can try playing it. This one was made with the GPT-5.6 Sol model; it’s quite good.

Dynamic Workflows is a feature on Claude Code. Translated, it means Dynamic Workflows. Based on the complexity of the task, it can write a JavaScript orchestration script and then automatically schedule and run dozens or hundreds of sub-agents in the background to work collaboratively, allowing Claude Code to perform large-scale, long-duration execution tasks in a single dialog. Now we can also add the Dynamic Workflows feature to Pi by configuring a plugin. Here I search for “workflow” in plugins, find the pi-dynamic-workflows plugin, and install it in the Windows console.

Start Pi, and here we first input “workflows” to trigger dynamic workflows via the keyword.

I ask Pi to research influential papers in the AI field from 2022 to 2026. Press Enter to start. We see Pi starts the Dynamic Workflows feature and launches 10 agents working. We can input the /workflows command to check its background work. We can see the work status of these 10 sub-agents; for example, selecting the first sub-agent, we see it’s mainly searching for 2022 papers, and the status is “running”. Using this plugin in Pi for dynamic workflows provides an experience almost identical to Claude Code, very convenient.

Now many desktop agents have the feature of connecting to mobile instant messaging. We can also configure this capability for Pi through a plugin. Here I go to its plugin list again, search for “instant messaging”. We install this plugin, copy it, open the Windows console, and install it.

After installation, start Pi, then input this command /wechat login, then scan the QR code with your phone to complete pairing.

Then input the command /wechat start to start the connection between Pi and your phone.

Let’s test it; in the phone’s contacts, find the Bot, and say hello first. A response is received. Then I ask it to check the weather in Jinan. On the computer side, we can see the message has come, and Pi also starts the task synchronously. After a while, the weather is checked and pushed to the phone; the effect is very good.

Agent Skills Configuration & Usage

Another important channel for extending Pi’s capabilities is Skills. Agent Skills have been a hot topic for the past year, and I believe everyone is quite familiar with them. Pi Agent follows the standard Skills protocol. We just need to place Skills in the appropriate location according to this path. Here it needs to be placed under the Project Directory/.agents/skills/ folder. If there are multiple Skills, place them all in this folder.

Let’s look at the first one, which I’ve repeatedly introduced in previous videos: Playwright CLI. This is a Skill that gives AI browser automation capabilities. First, we execute this command to install the Playwright CLI tool itself.

After the Playwright CLI tool itself is installed, we start installing the accompanying Skill. We can directly input this command, but I’m going to use another method. We see the source code’s directory /skills/playwright-cli/SKILL.md file is here. So what we need is to copy this folder out. Here in the code, click “Download Zip” to get the Playwright CLI source code. Then we find this Skills folder. Here I go to the project directory, create a new .agents folder, and directly copy the skills directory from the Playwright CLI source code we just downloaded into it. Let’s look at this directory structure: SKILL.md is placed under Project Directory/.agents/skills/playwright-cli.

This conforms to the Agent Skills standard. This way, Pi can directly recognize it. We still go to the project directory and start Pi first. We see Playwright CLI Skill is in the Skills. This is a browser automation Skill; it can automatically operate the Chrome browser to complete various tasks. Let’s try it; here input a command: open Google search and go to the Pi Agent official website, let me see the execution process. Start. Here Pi reads the Playwright CLI skill, operates the Chrome browser, opens Google, enters the search term, searches for the Pi Agent official website, and successfully opens the official website in the browser. Task completed, performance is good.

In the previous example, we placed the Playwright CLI skill under the project directory. If you want this skill to work in all projects, we need to place it in the global configuration directory, which is under the user’s ~/.agents folder.

Let’s try it. Here go to C:, find this .agents folder.

If this folder doesn’t exist, create one. This is the Skills I used in the project earlier. I directly drag the folder containing Skills from the project directory to the global directory. Let’s look at the directory structure again: User/YourUsername/.agents/skills, then the playwright-cli skill, and inside the skill is a SKILL.md file. This is fine. Next, we start Pi in any project. After starting, we can see the Playwright CLI skill in the loaded Skills. This way, we’ve transformed it from a project-level skill into a global skill.

Besides searching for skills on GitHub, SkillHub is also a good channel for finding skills. Next, let’s find a few interesting skills on SkillHub and install them. For example, I want to install this Markdown Converter skill, which can convert documents in any format to Markdown format.

We enter this skill. We can install it by downloading the zip archive and placing it in the specified directory, or we can try sending the prompt to the AI to let it install. Here I copy this prompt, then go to Pi and paste it to him. After a while, Pi completes the installation, but it indicates that my computer is missing uvx to run the Markdown conversion tool. Next, I tell Pi to install UV for me. After a while, Pi completes the installation of UVX. Then I find a PDF file to test. This is a PDF format lesson plan. I copy it, then go to Pi’s dialog window, press Control+V to paste it, and tell Pi to convert it to Markdown format. After a while, Pi completes the conversion, converting the PDF format to Markdown format.

Web UI Interface Installation & Usage

Some viewers might not be comfortable with Pi’s command-line style and prefer a simple and easy-to-use UI interface. In the community, many authors have developed some Pi Web UIs, integrating Pi into a webpage for use. The one with the highest stars should be this project, with 4,200 stars, released a few months ago by a Chinese author named “Fourth Chimpanzee”.

Let’s install it. Find the GitHub homepage, here “Quick Start”, we find this npx installation command, and execute it in the terminal, input y. After installation, it will automatically open a web-based UI interface where we can operate Pi.

We can switch projects in the top left corner. This shows several projects I’ve used in this video. We can also click “Custom Path” to open a local computer path as a project folder. Then Pi’s work is processed within this project.

The bottom left is the file browser, showing the files inside the project folder. There’s also a model button in the bottom left; we can configure model subscriptions here. For example, add a provider; here I configure a Kimi model, select “Moonshot AI CN”, create an API key in Kimi’s backend, copy this key, fill it in here, and save. Now we have a Kimi model. With a model, we can select these Kimi models in the model selector in the middle of the screen.

The bottom left can manage skills and plugins. For example, I select Skills; we see the skills listed here are divided into two parts. One is “project” skills, which are skills stored under the current project directory; the other is “global” skills, which are global skills. We can select the skills here and choose to enable or disable them. Disabling hides them from the prompt, so the model doesn’t see this skill. Timely disabling unused skills can help the model save tokens.

To the right of the skills are plugins. Similarly, plugins are also divided into “project” and “global”. Project plugins only work within this project; global plugins work everywhere. In this UI, we can also control the disabling or enabling of plugins.

Below the skill management panel, there’s an “Add Skill” section where we can search for and add skills. For example, I add a TTS skill, using Edge TTS here, which is a text-to-speech skill. It doesn’t need API key configuration; it’s completely zero-cost.

Then we can also choose its installation method: install to the project or install globally. For example, here I choose “project”, click “Install”, and the skill is installed. Let’s test it; I ask Pi to convert this text into audio and send it. We don’t need to specify which skill; Pi can choose which skill to use based on its working scenario. We see it reads the edge-tts skill and uses the tool to generate the audio for us. We click to play.

In the central dialog panel, we can also use slash commands to use Pi’s built-in commands, use the @ symbol to select a certain file, and we can also take a screenshot and press Control+V