Many people assume “letting AI do my work” means learning to code first, but in practice the bottleneck stopped being Python syntax a long time ago—today’s Agents can break down steps on their own, find files on their own, and drop the results onto your local machine. What’s actually missing is just someone walking you through installing one and pointing it at your own materials.

Pi is exactly that kind of Agent software—installed on your computer, barely managing the AI underneath. Pi isn’t the AI itself; it’s the software that lets AI get things done on your machine. Wire in GPT and DeepSeek and it can read three meeting notes for you, merge them into a single viewpoint summary, turn that summary into a sourced article, look things up online when needed, and even wrap a graphical interface around the whole thing. This post is a complete beginner’s setup walkthrough, plus recommendation guidance on four mainstream Agent tools.

Why Pi, Not Another Agent

Before walking through the full workflow, let me lay out three criteria. These aren’t software spec sheets—they’re a way of judging, from the angles of safety policy, ecosystem, and philosophy, which Agent software is worth trusting to do real work for you.

First: the less it manages, the more room the AI has to perform. Pi’s design logic is “less management = more model capability.” Stuffing too many rules into an Agent is like stuffing the model into a cage. I gave the same research-report task to OpenAI’s official Codex—the output was dry and unusable. Running the same task through Pi, the details and judgment you’d expect were all there. As models keep getting stronger, the Agent layer sitting on top should keep getting out of the way.

Second: it loads almost nothing into context by default—token consumption stays minimal. At its core, an Agent tool stuffs system prompts, tool descriptions, and its own rulebook into context. The bigger that load, the less room is left for the actual work. On my own machine, Pi barely uses a few K of context at startup. Switch to Claude Code in the same environment and it lights up 30–40K the moment it runs—half the token budget is gone before the actual task even starts. More importantly, Pi’s MCP and other extensions load on demand; it doesn’t walk in carrying the entire toolbox on day one. All told, Pi is one of the most token-efficient Agent tools available right now.

Third: don’t expect a single AI to handle everything. Today’s AIs are split—some are strong at code, some write beautifully, some research fast and accurately. Expecting one model to cover everything isn’t realistic. Pi can plug in GPT, DeepSeek, Claude, GLM, and other mainstream models all at once, and you’re free to pick which one runs which task.

Install Pi on Mac (Same Steps Apply on Windows)

Head over to pi.dev. For Mac, the official one-line install command is right there—copy it, paste it into your terminal, hit enter, type Y to confirm, and the download begins. It’s fast. Once installed, type pi and hit enter to launch it.

The first time you launch Pi, you’ll see Warning: No models available.—don’t panic, nothing’s broken, it just means you haven’t connected an AI yet. Windows users: swap the terminal for PowerShell; the installation command is on the official site, and every step after that is identical.

Wire Up Two AIs: GPT via Subscription, DeepSeek via API

1. Log in with your GPT Subscription

In Pi, type /login and hit enter. First pick “Account login (OpenAI Codex)”, then pick “Browser login”. A browser tab will open with the authorization page—log in with your account, head back, and you’re connected. After /login, Pi will display which models your current plan supports and how much reasoning quota you have. This is tied to your OpenAI subscription tier, not unlimited.

2. Connect the DeepSeek API

Open the DeepSeek Open Platform, register, log in, and confirm your account has a balance. Then create an API Key. One reminder: the Key is your master key—never screenshot it, never share it in a group chat, never paste it into a chat window.

Back in Pi, type /login again. This time pick “API Key”, find DeepSeek in the list, and paste in your Key. After saving, type /reload to refresh, and DeepSeek will show up in the model list. Pick a small model like DeepSeek Flash, and the status bar at the bottom will show the current model name.

At this point you have two AIs: one on the subscription plan, one on API Key. Each side tracks its own quota and billing independently—being both inside Pi doesn’t merge them into one bill.

3. Switching Models and Reasoning Levels

/model opens the model picker—grab whichever you’re comfortable with. Reasoning level is toggled with the Shift+Tab shortcut—simple tasks like organizing files can stay on low; tasks that need finer judgment, like writing an article, switch to high.

First Real Task: Merge Three Meeting Notes into a Viewpoint Summary

Talk is cheap. Let’s have Pi actually do something—merge three live-stream transcripts into a viewpoint summary with sources.

Prepare the Practice Materials

Create a folder on your Desktop called “Pi Beginner Practice” and drop three pieces of material inside—I used the Agent-tool segments from the last three live streams, each labeled with its date. For your own practice, swap in your own notes, meeting minutes, or customer interviews. One rule: work on a copy first—don’t throw real client data, account credentials, or private info in on day one. A working directory isn’t a safe. Pi runs on cloud AIs, so whatever it reads gets sent off to the provider.

Write the Prompt Clearly

Move into the folder, type cd followed by a space in the terminal, drag the folder from Finder into the terminal, then hit enter; type pi to enter Pi in the right working directory. Run this with GPT, and write the prompt with four things spelled out:

  1. Where the materials are (point at the folder)
  2. What to organize (three themes—“how to choose Agent software,” “how to combine AIs with extensions,” “how to set up Chinese writing”)
  3. What to watch out for (merge duplicates, keep sources)
  4. Where to save the output (use a clearly named output folder)

After you send it, Pi reads the files and writes the output on its own—no copy-pasting from you. To watch what it’s doing step by step, press Ctrl+O to open the execution trace. When it’s done, open the result in Obsidian—the themes are merged as requested, and the sources are clearly marked.

Second Real Task: Switch to DeepSeek and Write a First-Person Article

Same folder, same materials—this time only swap the AI. Type /model, pick DeepSeek, set the reasoning level to high, then send this prompt: “Take the summary document you just wrote as source material, and write a first-person article called ‘Why I Mainly Use Pi Agent Now’, 1000–1500 Chinese characters, focused on three points: 1. Why I use Pi Agent for daily work; 2. How I match models to tasks; 3. Why I don’t recommend installing lots of extensions. Keep the language natural and conversational—don’t sound like an AI.”

Pi picks up the output file from the previous step as input—you don’t have to copy anything over. When it’s done, read through it. The opening no longer starts with “With the development of AI…” and goes straight into the topic. The tone sounds a lot like me.

Here’s the takeaway worth keeping: pick the model to fit the task, not the task to fit the model. Organizing notes goes faster on GPT; rewriting Chinese prose feels more natural on DeepSeek. Together, those two are your daily workhorses.

Give Pi a Web Extension: Pi Web Access

The first two tasks only touched local files, but looking up something that just happened requires the network. To give Pi web access, install just one extension: Pi Web Access—don’t load ten at once. The reason is the same as before: the less the Agent layer manages, the more room the AI has to perform.

Install and Restart

Just tell Pi directly: “Install the Pi Web Access extension for me.” It will figure out how to install it, then run the installation itself. When it’s done, Pi will tell you “Restart Pi for it to take effect”—don’t skip this step. I skipped it once and the extension didn’t load.

An “extension” is a small program that runs on your machine, so have a clear head before installing anything. Once it’s installed, just have Pi look up some current event—say, a trending topic right now. It will search on its own and come back with a sourced summary report.

Zero-Configuration by Default

Pi Web Access works right out of the box with no config needed. If you’re already logged in with an OpenAI subscription, search traffic goes through OpenAI’s own search endpoint—you don’t need a separate search Key.

Want to Switch Search Backends? Tavily

If you’d rather not use OpenAI’s official search and want a third-party source, Tavily is the recommendation. Sign up at tavily.com, create a search Key—the free tier gives you 1000 credits a month, more than enough unless you’re doing heavy searching every day.

When configuring the Key, do not paste it into chat and ask the AI to fill it in for you. The right way is to use environment variables or a private config file—let Pi write the config structure out for you, then fill in the Key yourself. Or use a PI proxy; don’t hand over the key. Once it’s set, tell Pi:

“When using OpenAI’s GPT, route search through OpenAI’s own search. When using DeepSeek, route through the Tavily I just configured.”

It will automatically pick the right search backend based on the active model. Pi Web Access also bundles Exa as a fallback—zero config, ready to step in once your free quota runs out. In practice, one search source is plenty—don’t wire up everything at once.

Don’t Want the Terminal? Use Paseo to Wrap Pi in a GUI

Pi doesn’t have a desktop app of its own. If you don’t want to live in the terminal, Paseo is the recommendation—a third-party open-source tool that wraps all kinds of Agent software in a graphical shell.

Download and install Paseo from its official site. In the bottom-left corner, click “Settings”, find Providers, and flip the switch next to Pi in the list—Paseo will load Pi in. The 10 GPT and DeepSeek models I’d already set up in Pi all loaded in.

Back on the main screen, add a workspace, point it at your Desktop “Pi Beginner Practice” folder, then start a new chat and choose DeepSeek from the menu—check the top-left to confirm which Provider is selected. From here, you can boss it around just like any normal chat app.

Paseo has a pull-out file panel on the right—the three source documents and the generated article all live there, no more bouncing between the terminal and a reader. Want to tweak a sentence? Switch to the source view and edit directly inside Paseo. Walking through the workflow in the terminal first is meant to show you where everything lives and how it works around files. For everyday use, you can do everything inside the GUI and don’t need to go back to the terminal.

How to Pick Between Four Mainstream Agent Tools

Once Pi is in your hands, this question will probably come up: Codex, Claude Code, Open Code, DeepSeek Harness—how do they stack up? Here’s my own usage pattern and how I think about the trade-offs.

Software Best For Not For My Usage
Pi All daily non-coding tasks: organizing files, research, writing reports and proposals Complex multi-file architecture design Main tool, 70–80% of workload
Codex (OpenAI) Writing code, code review, backend design, architecture design Research reports, frontend design Coding-only, strict guardrails
DeepSeek Harness Running DeepSeek models for code (cache optimization, token savings) Chinese writing (too AI-flavored) Kept around occasionally
Claude Code Strong feature set Highest token consumption Almost never use it
Open Code Full feature coverage Too bloated Abandoned

My principle fits in one sentence: Agent software and AIs are separate decisions—I pick the AI for the task and the Agent software to match. Codex and DeepSeek Harness are both solid, but they’re Agents pushed by the AI vendors themselves, optimized for their own models—using them is like working inside someone else’s pre-picked combo. I don’t want to be locked in to any one of them, so my main Agent is the neutral Pi, and the model layer stays free to mix and match.

For a deeper look at how AI Agents are shaking out, see AI 大模型运行机制原理一篇; Codex ChatGPT 半年更新：省 token 技巧 covers a similar “save tokens via context” angle; and 一周 AI 行业 10 件大事 is a fast read on where the industry is heading during this period.

Wrapping Up

Once you’ve done the four things above—installed Pi, wired in two AIs, had it organize files and then write an article, bolted on a web extension, and wrapped a GUI around it with Paseo—you’ve got a Pi Agent setup you can use every day.

The heart of the whole workflow isn’t any single step—it’s these three habits: “pick the model to fit the task + install fewer extensions + keep Agent and AI decoupled.” Agent software itself will keep multiplying, and models will keep getting stronger, but the logic behind these three habits stays steady.

A few things I didn’t cover this round: scheduling multiple Agent software inside Paseo to work shifts like employees, and remoting into your home machine from your phone. Those will come in follow-up tutorials. If you hit issues during setup—Key leaks, models throwing 401 errors, Paseo not loading Pi—drop a comment. The next post will turn those into a runnable checklist.