Couldn't agree more. The vanilla openclaw install was this byzantine mess of MD files talking about souls and identities and such, it really put me off. Stripping back to a bare install of the underlying pi, it was delightfully minimal and easy to reason about. Excellent starting point for building an assistant agent without having to read or fight with a bunch of cruft on top.

Couple skills to integrate with an obsidian MD task tracker, small chat interface on the phone made public via tailscale, and bam, a reminder bot you can text from the grocery store.

You inspired me to try Pi out - so far it's worked flawlessly. Plugged it into OpenRouter and ~$.50 of Deepseek later I've installed llama.cpp and Llama 3.1. The local model doesn't work with Pi yet (and I know it will be bad and slow even if it does) but I'm curious to see what you can do on an 8GB consumer GPU these days...

"Been running it almost barebones vanilla for a couple of months. Just a bunch of basic extensions and some skills."

I am also using pi exclusively after having had decent success with openhands but begrudging all of the docker infrastructure ... and all of the emojis.

My only pain point is that in my extremely common and boring workflow, which is pi inside of gnu screen inside of OSX terminal.app ... all reasoning/thinking text is blinking ... like old fashioned ANSI blink on a BBS.

I cannot figure out how to disable the blinking thought/reasoning text ...

I use oh-my-pi, not sure how it compares, but I say someone praising antigravity for being a good harness(1), and for the love of good people settle for such low standards of user experience it's almost pitiful.

(1) https://news.ycombinator.com/item?id=49913854

This bug was fixed several months ago; you just need to switch to full-screen mode, though you hadn’t done so previously.

However, they have now set full-screen mode as the default.

Are you using Windows Terminal by any chance? I'm building a personal fork [0] with a patch for this exact bug (plus a few other open PRs from the upstream repo that seemed cool). Haven't tried contributing it upstream, since the patch is fully vibe-coded and I've spent almost no time trying to understand how it works, but the bug hasn't recurred since I've been using it.

[0] https://github.com/wilt00/windows-terminal/releases

You're looking for fullscreen TUI mode: https://www.reddit.com/r/PiCodingAgent/comments/1vh5pys/than...

I wonder much the same thing, but this seems like a slightly odd place to say it since so far as I can see the only LotR name in the linked article is the company name Earendil, and AFAIK Earendil-in-Tolkien was very much not corrupted by darkness.

Well there’s https://disconnect.blog/peter-thiels-influence-over-a-networ... and https://www.reddit.com/r/lotr/comments/1lrc27y/how_do_tolkie...

“The Shadow that bred them can only mock, it cannot make: not real things of its own. I don't think it gave life ..., it only ruined them and twisted them.”

Hey thanks for posting this. I use pi professionally too. I am curious how you used agentic workflows with pi before. The simplest(since the early days) was letting it use Tmux for spawning other sessions and controlling it.

The second case, more recent, is one where I use actively now is linking pi sessions to some artifact like a code change(PR or diff) or a collection of document and then continuing the session in that context.

What was your main power case with it.

You have made me excited to try it. Thanks for the tips.

It's table stakes for using Anthropic APIs cost-consciously. They aren't building a minimal harness for nerd points; they are building it to be usable, and dogfooding it with Real Money to learn what that means realistically.

This might've made a better argument ca. 2005 wrt a 20-something Austrian's minimalist wsgi framework. Heck, I'll bet you could even find said argument somewhere in the Archive :)

Yeah, it's such a subjective feature. I don't really worry about the five minute timeout, but sometimes if I'm conscious about the fact that I have an 800k token context window that I haven't interacted with for a day, I will switch to Opus for compaction and then back to Fable for interaction.

In general, though, some kind of API ping on a timeout does not support my personal workflow, which involves dozens of active or stagnant agent sessions that stay open for weeks.

because "i came back from lunch and my fresh 5h usage limit evaporated" is not a feature

i guess you could blame the api, if you wanted.

I don't use Pi very much for actual writing code. I have some specific use-cases where I do, but I'm admittedly just not a person who can reasonably juggle a lot of tools or a super personalized setup. I mostly just use Codex or CC from the terminal, though I've recently dabbled with some GUIs. Basically, once I find something that works, I'm pretty reticent to spend any time tinkering unless I feel a real need.

But what I do use Pi a lot for is as a base for agents. I much prefer it to using an agent SDK. I find its minimalism and extensibility to be a really nice substrate for new projects.

I could easily imagine someone getting to a really productive personal setup with it as well, for the same reasons as above.

I use PI WEB (https://pi-web.dev, there's more than one with that name) to orchestrate remotely. Pi lets me run local models (currently Qwen 3.8 Flash Next on Strix Halo 128GB) and flagship models (with subscription auth, not API pricing) side by side. I typically ask GPT 6.1 Sol to review requirements and then spawn a subsession with Qwen, review Qwen's work, ask Qwen to fix. About 95% success with a single pass like that, achieving flagship quality without the price tag (albeit slower).

I started using Pi because it has a small system prompt and local models were too slow to start. Then I started adding custom skills and extensions when I hit little corner cases. It's been so easy to bend into what I need.

I’m also looking for tips. I feel like I get the gist, but if I sat down to use it, I don’t know what I want to start with. Like, I know it’s customizable, but what’s the on-ramp so I can figure out what that looks like?

I've only used it at home a little on personal projects. My usage is probably odd -- I connected it with Bedrock, but otherwise used it the same as I do Claude Code (mostly). My basic flow was simple:

  - Ask it to accomplish some coding task
  - If it fell short, and I determined that was due to the harness, ask it to patch
  - Otherwise proceed to next task
  - Rinse + repeat

The light weight prompt and simple harness design are a lot of fun. I don't mind Claude Code, and I think its well designed for the problem domain, but Pi is a lot of fun to hack with.

Hope that helps!

[1]: https://mariozechner.at/posts/2025-11-30-pi-coding-agent/#to...

I use pi with a ChatGPT subscription. I find that it does better than the native codex harness: - it's very token efficient. I've had whole profiling + refactoring sessions finish in <20k tokens, whereas in codex you can get close to that with just all the cruft OpenAI loads by default before you even send your own messages - the token efficiency means turns are a lot snappier - fine-grained context control by default - I have to disable a bunch of stuff in codex so it doesn't pollute my context with generated memories - I find that OpenAI model sometimes struggle to navigate codex' sandboxing, and burn a bunch of tool calls retrying outside the sandbox when the sandboxed command fails

I use claude code and codex in a terminal like a caveman too.

then i use pi in a terminal like a caveman to try the open models like deepseek etc.

I also have pi running on a VPS. I have a custom Django app that calls out to it for a bunch of stuff. I don't know how the full system works because the agents built it but basically I think one pi uses a whatsapp wrapper to constantly listen to a whatsapp group and find bills. Then those get added to the Django Database which triggers a second pi + deepseek to OCR them, parse out the data like amount, due date, reference etc, and update the database with that. I have a trigger to 'merge duplicate', which is also just a prompt and pi.

Yes you can do all this without a harness and just the model APIs directly but the harness means it can use linux tools to crop the PDFs etc, so when I also wanted a new feature that crops out the bank details and lets me hover over and see the original before making the payment for a bill that's just another tweak to pi's prompt (or more meta, me prompting my agent to update pi's prompt).

I use my Pi to organize my graphic design assets as well as update documentation for client projects. It also is my daily driver for a story I'm working on and thanks to a ton of great skills created it has become more powerful. Local model is Qwen3.6 35B-A3B and Qwen3.8 27B UD. I love the compressing function, keeps on pushing.

I've tried Oh-my-pi but it's too heavy for me and eats up 6% of my context on start. Also I find Pi's keyboard shortcuts easier to use.

I use WSL, one tab is GitBash running llama.ccp and the other is normal terminal running pi. Winning combo for me.

Also started using Pi as my search engine, which I've refine and does what I need it to do, can also ask it to create a html doc with links or markdown. Fun stuff.

I use Pi in the terminal and with Zed (with its "right hand side" terminal bar you can make its agent panel do), and I use it with Pendant in VSCode at home: Pendant is really quite impressive, I'll be honest.

It's been pretty useful for experimenting with local models due to its more light-weight approach. Though I respect the creators a ton, OpenCode has not seemed to work as well with models that run on consumer hardware

I've put it into an XMPP wrapper for all communications so I can talk to my agents from any device supporting XMPP (all devices). This also means agents can talk to each other using group chats. I'm building apps from my phone on the bus, and handing off server admin tasks to the agents since they run in their own NixOS account with limited permissions.

Ten people have replied to your question (which is the same question I have) and not one of them have answered it so I figured I’d be number 11.

Like, is this thread full of astroturfing bots? What am I reading

You just type "pi" in the command prompt and you're good to go!

The only thing I've configured is the default model.

I built and “ide” around it in obsidian. Works great. And I don’t need to jump between apps to change models. Astra and opus in same chat works just fine

I believe this is the popular "batteries included" kit: https://github.com/can1357/oh-my-pi

Pi is popular for local-models/alternate-models. It's not much different from Claude Code and Codex otherwise.

I use Pi with only a couple of extensions and using less and less of CC and Codex everyday. It feels light and nimble. Codemode from yesterday's release made it even better. I wish I could use my Claude subscription via Pi.

Absolutely. Fellow caveman here, and a fan of Pi. I often use it with Astra instead of Codex, because its extensions allow you to connect it to the world. And it works very well.

I built my own based off another popular harness. I figure most of the edge cutters are doing the same.

Pi is great overall. I ended up deploying a GUI wrapper because TUI isn't as friendly to new adopters.

Vanilla Pi is great. I have a subagent/ Ralph loop extension I coded and that's basically it. It works very well. I'm about 75% pi, 20% autolith, and 5% my own harness

Exactly like that. Just install it, connect a provider and do stuff.

You don’t need extensions or fancy setups.

> Here I am with Claude Code and Codex in a terminal like a caveman

There's definitely a class of folks who like to "polish their tools" per se vs tools just being as a means to an end.

It's fine and cool, sort of like the desktop ricers do with Hyperland, Niri, etc showing off desktops, but never seem to do anything with this cool tech.

Using models from multiple providers via aws bedrock

I use workmux with pi plus some neovim plug-ins

Extensively, almost as much as I use my editor.

I have eight or nine custom extensions at varying levels of maturity, some nearing the point where sharing them becomes useful.

One is a simple but obvious Eoka extension for Pi.

I modified my terminal (Alacritty) to support the Kitty image protocol (it already spoke sixel; Pi understandably uses the superior Kitty protocol). And a toolcall that lets the LLM put an image in the transcript (upstream Pi lets only image-modality LLMs do this). "Deepseek, do XYZ in a headful Chromium using Xvfb and show me a screenshot before each step".

Once you see the immense power you get from being able to modify both ends of the terminal connection (and having LLMs write the tests and tedious parts for you) it's addictive. I've added a custom terminal extension for negative-row-number cursor positioning, and support for it on both sides of the connection (Pi and Alacritty). End result: all the performance of native scrollback with no compromises -- Pi can modify rows above the top of the visible part of the screen, like collapsing/expanding toolcalls, without forcing a full-terminal refresh.

Also: click-to-expand/collapse toolcalls/replies individually. Really helpful.

Disappointed that Pi is abandoning the minimality philosophy.

Pi vs opencode for example is like gentoo vs macos, if you want to spend your time customizing and dealing with harness itself rather than doing the work, then go for it, it will be fun, like gentoo. I think the best productive setup is herdr+opencode or zed and opencode, unless you need CC for anthropic models. The only thing however, is how the same model works with different harnesses, positive or negative, is where you might need to shuffle between to maximize the results.

They are not, Pi is the vim or mechanical keyboard of the pre-AI era. Didn't matter then, doesn't matter now. Will generate infinite discourse regardless.

Frankly you are not losing much. I've used everything under the sun, for work and fun. I just use Claude now again for work, and I use Pi for any openrouter model I'm using.

Just keep using Claude or Codex.

It's all window dressing and some delta in token usage, but again who cares really?

This really only matters when you're productizing "AI" for your end users, that's when you need to see which agent uses tools better, has more support for MCPs, headless mode, sessions, etc. \

the main thing i use it for that seems like a pain with other coding agents is my sandboxing workflow: i have a custom extension which allows the pi process to run on my laptop, keeping all my transcripts in one searchable place, while delegating all the bash and file system commands to a VM.

i haven't gotten around to it yet, but i'd also like to change how `Bash` functions on a basic level (and subagents), where rather than the agent picking a fixed timeout, it just gets notified with exponential backoff about commands that aren't done and then gets a turn to decide what to do with it.

having said that, i find it annoying and not empowering that basic things like subagents and web search aren't built in. the ideal to me seems to be an agent with polished extensions for all the common use cases that can be disabled if you do want to rewrite them. but i put up with the pain because i really want my pet feature ¯\_(ツ)_/¯

I use it headless for reviews in CI.

And you're probably more productive than the people using Pi. Although you'd be even better off using a GUI agent multiplexer of some kind rather than juggling terminal tabs.

I love open source. I love the terminal. I spent the last 20+ years in a terminal w/vim every single day, and then claude/codex TUIs, and yet I care more about my own productivity so I don't use any of that now.

Stateful Kubernetes is a royal PITA. I would just throw stage into object storage and call it a day.

I think you should look into Pi Durable wich was just released right now too. seems like it is made for your use-case.

I tried Pi a while ago and found it a bit tough to use, OpenCode was pretty simple, but oh-my-pi is really head and shoulders above the two others. Really great.

Paseo is great and has mobile notifications but it’s not as polished as omp web.

That looks interesting, built it (took seconds) and it is much smaller than Pi in terms of what it needs to work (when i installed Pi in a fresh Debian container it downloaded ~500MB of stuff, which isn't exactly what i had in mind when i read it is minimalistic :-P but it is a container so i didn't care much).

I'm just running it now in its own source with Qwen 3.8 27B and llama-server and asked it to analyze the code itself. I'm mainly curious to see how it handles context compaction during tasks (what Pi does is almost seamless and AFAICT it isn't anything particularly fancy so i'd expect Hax to do something similar) and i guess asking it to analyze a whole C codebase would help trigger that with a 131,072 context. Unfortunately it seems to be missing some "context usage" indicator while it does stuff (it shows context usage in the prompt but not while working), but i guess if it does manage to analyze the C code properly, i can ask it to add that :-P and see how it fares (from my use of Pi i'm positive Qwen 3.8 27B can do all that stuff, so it'd mainly be up to the harness).

EDIT: also i wonder if it works nicely if it is possible to convert Pi transcripts to Hax - i have a few "in progress" and i'd like to continue where i left from, though while both seem to use JSONL for the transcripts i'm not sure if they're compatible

EDIT2: hrm, it tried to use more than available tokens during a compaction and stopped there expecting me to increase the limit (i can, but what if i couldn't?) and restart the llama-server. Pi sometimes does hit it but it manages to recover by itself without requiring any input by me (or to increase llama-server's limit).

Yeah I think Pi just abandoned the prize and hax is the heir apparent.

Pi's selling point used to be: no MCP, native scrollback.

Now Pi is a fullscreen TUI with built-in MCP.

It says "local models" - do you know if it makes any special effort to fit work within a small context window?

What hardware do you run Qwen 3.8 Flash Next on?

I think you're right, but in the wrong direction. I'd imagine it's closer to a million.

- It has 3.6 million weekly NPM downloads.

- 110k GH stars.

- It's 5th (and its fork is 6th and a dependent is 8th) in monthly Openrouter tokens. Add them all together and they get close to Claude Code numbers.

I think openAi said that 40% of their api request come from opencode, claw, pi and similar.

Not a proof, but that makes it sound more plausible, no?

How do you know?

I hear you. This post and the comments smells like Astroturfing to me.

Full screen hides distractions from other applications. Seems reasonable as something minimal.

Minimalism is a difficult subject. In art, minimalists tried to strive for something that is universally minimal. But if you look in nature for straight lines or perfect circles, you end up disappointed. Turns out minimalism found things that were minimal with respect to how some humans think about minimalism. For all we know, pure chaos may be more universally minimal than an empty vacuum.

Yeah I’m hoping that they don’t remove or devalue the (now legacy) renderer

it's not static though, it's got a cool animation

I found this: https://arena.ai/blog/coding-agents-harness-tax

Seems to support my skepticism.

I think it's often the other way around. The differences in perceived coding productivity that many people attribute to claude vs codex is more the harness than the model it's running (if running comparable classes of models).

I'm no academic, but I have read that harnesses dictate the output more than the models themselves. I'm not educated enough on the topic so I will defer to those smarter than me to chime in.

I have run into some models that seem to mind. Like for the life of me I couldn't get North Mini Coder to play nice on Pi, which was sad since it seemed good otherwise. It just couldn't grasp the tools.

Classification models have been around for literally almost a century at this point. I think it's safe to say they are a proven technology.

The only thing that makes Jev and the likes particularly interesting is that it is a general purpose classifier. In the past, classification tasks meant training a new model to solve your problem. Now you can just use an off the shelf general purpose model and hit the ground running.

> but MCP has been growing for nearly 2 years, and it only gets support now?

I don't know if you were aware, but not shipping with MCP was one of its "features":

https://mariozechner.at/posts/2025-11-02-what-if-you-dont-ne...

They let you have it via a plugin/extension.

It was already very good and has been used/battle tested by many us for a long time.

Some tools used to be 0.x for ages and, in this case, the 1.0 signals they're happy enough and allows them to promote things in a better way.

This (edit the durable part) is I guess the natural evolution of playing around building temporal like things for a need that many have.

the latest 07-28 MCP spec is quite different than the previous iterations of MCP, so I understand the delay there tbh.

Armin from Earendil here. I think the question is fair, and quite frankly the answer is pretty disappointing: we look at what the models are doing. They are trained on their respective harnesses and we're not here to fight their behavior.

Codex in particular is using responses lite internally and relies on codemode for parallel tool calling. So codemode was a given.

Jev on the other hand is new but it's not the first type of model we had troubles with supporting in Pi and we looked at how to make that make sense. The internal pi-ai SDK supports image generation and classifier models, but without building an extension it was never possible for you to utilize it.

So there was a while functionality of Pi that few people used, because there were no obvious ways to hook it up with the coding agent. Codemode also allows us to close that gap.

And once you have codemode, modern MCP can work quite well if the servers cooperate.

I agree. I don't necessarily "trust" Anthropic and OpenAI when it comes to CC/Codex respectively, but I respect that they have immense internal resources and telemetry to be able to understand what features move the needle and nudge traces in the right direction. I don't understand how non-labs judge feature inclusion? Just vibes?

Human judgement is a thing.

There are Rust alternatives to pi and folks are welcome to use them.

I find Typescript more approachable in many ways like compilation speed, extensibility, disk space used by cargo, LLM knowledge, and most devs I know already have node or bun installed anyway but not cargo, including me.

The speed in which pi can modify and extend itself is part of the appeal to me.

They actually mention this at the end of their post on Pi Durable[0]: > Why TypeScript again? Because it is the easiest way to bootstrap this. But as everybody knows by now, it's very easy to port everything to Rust or assembler. We're not ruling this out in the future, but at the moment we are focusing on TypeScript.

[0]: https://earendil.com/posts/pi-durable/

> I love alternatives to the big players but why is everything written in TypeScript or Python and takes up a gigabyte of ram.

Same reason everything's an electron app now. First mover matters to the makers and to the consumers more than performance and attention to those details.

Totally agree with this sentiment. On your plugin point, I recently did a PoC of QuickJS in wasmtime with a restrictive sandbox (10 syscalls total) for running untrusted plugin code and it was great. Took maybe 3-4 days to pull together and performed more than adequately for the kind of thing this class of software needs, with a security posture that beats pretty much anything widely deployed. When this level of engineering excellence is so cheap to achieve, we really need to bully companies that refuse to do it.

Good grief, a voice of reason.-

I am really hoping a combination of the RAM-pocalypse and AI coding will result in less bloat. At some point ...

I was so frustrated about this that I ended up writing my own.

> AI lowers the barrier of entry to Rust to virtually 0

Not really. It lowers it, sure. By a lot even. But you still have the system requirement for compilation and ecosystem to deal with.

Pi with rpiv-ask-user-question, pi-subagents (if you don't want to use tmux), pi-web-access (if you have a subscription to some search backend), plus agent-browser CLI. I don't miss anything in Claude Code.

As someone similarly invested in Claude Code and initially reluctant to try other harnesses, I recommend the batteries-included Pi distribution oh-my-pi (omp.sh) over Pi and OpenCode. I switch between Claude Code, omp, and Codex regularly, and it feels fine.

I've recently adoped pi at work and its been a treat. I think just starting with the base agent and installing (or creating) plugins as the need arises is best. If you really want some plugins to start with pi-subagents and the rpiv collection are what I'd recommend.

I'd say it's the other way around: I like Pi because it's minimal. Not like claude code spinning up superpower:* skills, 10 background agents, etc. Also, it's a useful building block for so-called "agentic workflows" precisely because it's minimal.

EDIT: forgot to mention local models

The minimal setup is nice to customize per project or set of projects. Tailor made specific for the use case. Only grab extensions where necessary, I've made a few for myself and work to help me.

Not what we stand for: https://earendil.com/values/

the exception to prove the rule I guess

I didn't even think of that aspect of it. Just a poor little guy who sits there watching journalctl and occasionally yells when he sees something.

Pi is very minimal. That's the main difference between it and OpenCode. Although OpenCode has a new version called OpenCode Mini... which reminds me I told Dax I'd give it a whirl- so thanks for the reminder, stranger!

I wrote my own minimal coding harness last year because I hate software bloat, but Pi scratches that itch for me now.

Adding MCP and code mode seems so antithetical to the minimal ethos, I almost would believe they got incentives from Jen, but I don't want to be that cynical.

Can you explain your workflow a bit please? Do any of these tools work with Claude/Codex subscriptions or are they API only?

I actually built my own tool that maintains a work graph (DAG-like) with task leases. It allows me to copy and paste pre-written prompts into Claude Code, Codex, or OpenCode and all the agents self-coordinate through MCP calls.

I built this after trying hermes and Openclaw but not liking the lack of human-in-the-loop judgement. So I'm wondering if I should keep refining my tool, or evaluate something like pi?

IIRC, this was a deliberate choice from the creator who originally wanted the project to be hard to find!

We did not want to waste this opportunity this early but we released at 3:14 ET :)

And every later version should add a digit.

https://tex64.com/learn/getting-started/about

Woah, this is my first time hearing about Autolith. Definitely looks cool, I might have to play around with it. How do you find models do with Lisp? I have had some trouble with my models getting tripped up pairing parenthesis in my GNU Guix configuration.

Well, check out rcarmo/gi - I am using my clojure interpreter inside it as a scripting engine.

I had the same concern last time I looked at Pi. There's no way to tell which are useful and semi-vetted and which are junk. I came to the conclusion that most people had their AI build them whatever plugin they needed, and I think this is even something they recommend.

What harnesses do you recommend?

It is written in TypeScript, not JavaScript.

TS probably has the most expressive type system of any language that I have used, and you can develop at lightning speed without fighting the borrow checker or anything else. The ability to share the exact same code across the front and back end, and encode API contracts in the type system, is a superpower for webapps built with node.

Whether an LLM writes the code or not is besides the point. What matters is that the code should be testable, and understandable. TS wins on both counts, like most sane alternatives.

I personally do not program using any language that does not have the ability to specify types.

I wouldn't go as far as calling it a joke language (in some ways, it's incredible), but I did come here wondering if other people felt this way. The language choice has always confused me.

On the other hand, I don't think there's anything Pi does that another language would do noticeably better from a user's perspective. Any performance complaints I have using Pi come from twiddling my thumbs waiting for Sam Altman's servers to bestow tokens upon me.

At any rate, they'll probably have Opus 6.5 and GPT-7 Galactica rewrite it in rust in a couple months...

What would be a better language? Most of the harness apps will be spending most of their time waiting for the models response and tool calling rather than running their code.

Languages with less opensource footprint or too verbose are at the losing side in a llm-driven world.

Pi is extensible, and to iterate new extensions, install them, create your own, even if the agents needs to, it is much faster and easier to manage that than a compiled language I would suppose. Most of the time it's really the waiting time than anything else. If any, the "resource intensive" parts of the app could be turned into low-level extensions such as writing or reading files, maybe, but the main part of the app makes total sense. The language and ecosystem is fairly accessible as well, which serves as a further argument. Interesting choice of words when it comes to calling it "joke language" really.

One reason: it's really easy to have a lightning-fast dev loop when the entire running process can hot-swap almost every piece of code, when then also extends to all extensions written against the core functionality.

When I first saw the domain it looked to me like someone's personal blog. I felt like they should have posted this on pi.dev...

> despite probably hating both Tolkien's message and humanity altogether.

Everything points to Thiel not understanding a thing about Tolkien. Tolkien was an old-fashioned conservative. He was all about protecting the environment and the old way of life (both things Thiel and modern self-styled "conservatives" strive to destroy). His role models were great because they made great sacrifices and showed strength of will, not because they used power for power’s sake and as a weapon for domination.

Thiel just does not understand the "humanity" aspect. I’d rather have them stick to Ayn Rand references. It made ignoring them or laughing at them easier.

Pi is a minimal agent harness, so lots of functionality is provided through packages. Here's the one that exposes Claude models for people to use with their Pro subscription, for example: https://pi.dev/packages/pi-claude-bridge

Claude is not but codex is. Which is why I switched.

I like a sandbox, but there's arguments for all three. Jai is still my favorite on Linux.

Local Qwen 3.5 on CPU was good enough for small tasks.

You can use it with oai subscriptions

I've read this a bunch of times around socials now these past days and I'd really like to understand what exactly indicates that the minimal agent TUI days are numbered for Pi?

I did not read this when I added support for AGENTS.md, skills, llama.cpp, extensions, alt TUI mode, mid-convo system messages and tool set changes to preserve KV cache, image model support, and everything else I added since November last year.

Codemode and MCP support are the latest additions. We follow what the models are trained on. E.g. the GPT family of models is actually trained on codemode for parallel tool calls now. The MCP spec has gotten a major update recently that makes it much less bad than it used to be in the past 24 months. Combined with codemode, it is now passable, so it got added to pi.

All of these features are still entirely optional and the only thing I could think of that could be considered "bloat" is the additional few megabytes for the QuickJS WASM blob.

So, I mean this in earenst and absolutely not combative: could you explain what exactly flips the switch between "pi is minimal" and "pi is not minimal"?