Pi – A minimal terminal coding harness

by kristianpaul • 5 months ago

608 306 5 months ago

cyanydeez• 5 months ago

The backing to OpenClaw/MoltBot whatever they're calling themselves. Why is it insecure, well, Pi tells you >No permission popups.

Anyway, even if you give your agent permission, there's no secure way to know whether what they're asking to is what they'll actually do, etc.

himata41134• 5 months ago

you want to put agents in a sandbox instead such as bwrap anyways.

chriswarbo6• 5 months ago

Why is it insecure, well, Pi tells you >No permission popups.

Pi supports permission popups, but doesn't use them by default. Their example extensions show how to do it (add an event listener for `tool_call` events; to block the call put `block: true` in its result).

there's no secure way to know whether what they're asking to is what they'll actually do

What do you mean? `tool_call` event listeners are given the parameters of the tool call; so e.g. a call to the `bash` tool will show the exact command that will execute (unless we block it, of course).

cermicelli• 5 months ago

Just how expensive was that domain?

jotaen• 5 months ago

README on Github says “pi.dev domain graciously donated by exe.dev” (though that doesn’t say anything about the original price of course).

schpet• 5 months ago

oh that's kind. i hope they keep the old domain up too though: https://shittycodingagent.ai/

arjie• 5 months ago

Has anyone used an open coding agent in headless mode? I have a system cobbled together with exceptions going to a centralized system where I can then have each one pulled out and `claude -p`'d but I'd rather just integrate an open coding agent into the loop because it's less janky and then I'll have it try to fix the problem and propose a PR for me to review. If anyone else has used pi.dev or opencode or aider in this mode (completely non-interactive until the PR) I'd be curious to hear.

EDIT: Thank you to both responders. I'll just try the two options out then.

rcarmo12• 5 months ago

You probably want to look into pi then - it's extremely extensible.

dosinga• 5 months ago

you can run https://block.github.io/goose/ in headless mode (I work on goose)

evalstate• 5 months ago

fast-agent lets you do this as well (and has a skill in its default skills repo to help with automation/running in container/hf job).

fred_tandemai2• 5 months ago

Been using pi exactly for this and it's working great!

chriswarbo6• 5 months ago

pi has an RPC mode which just sends/receives JSON lines over stdio (including progress updates, and "UI" things like asking for confirmation, if it's configured for that).

That's how the pi-coding-agent Emacs package interacts with pi; and it's how I write automated tests for my own pi extensions (along with a dummy LLM that emits canned responses).

mihneadevries• 5 months ago

Aider's `--yes` flag combined with a git-based loop works honestly better than I expected for this, like it'll just commit and you review the diff. Pi I've tried headless and it's fine but you kinda have to wire up the exit conditions yourself since it's so minimal by design.

Fwiw the janky `claude -p` approach you described is actually pretty solid once you stop fighting it, the simplicity is the feature I think.

alchemist1e9• 5 months ago

Finally found another Aider user to ask. How does Pi compare to it?

jmorgan2• 5 months ago

I've been using Pi day to day recently for simple, smaller tasks. It's a great harness for use with smaller parameter size models given the system prompt is quite a bit shorter vs Claude or Codex (and it uses a nice small set of tools by default).

rpastuszak• 5 months ago

Which models do you use and what for? I'm looking for ideas to play with.

jmorgan2• 5 months ago

For local models I've been trying it with GLM-4.7-Flash and the new LFM2 24B model. I'm excited to try it with the new Qwen3.5 models that came out today as well.

rcarmo12• 5 months ago

My current fave harness. I've been using it to great effect, since it is self-extensible, and added support for it to https://github.com/rcarmo/vibes because it is so much faster than ACP.

badlogic3• 5 months ago

wow, i love this! was about to build this myself, but this looks exactly what i want.

rcarmo12• 5 months ago

The better web UI is now part of https://github.com/rcarmo/piclaw (which is essentially the same, but with more polish and a claw-like memory system). So you can pick if you want TS or Python as the back-end :)

gusmally• 5 months ago

Which ones have you compared it against?

rcarmo12• 5 months ago

Literally all of them: https://github.com/rcarmo/agentbox

baby2• 5 months ago

Wdym harness? Its a coding agent

furryrain2• 5 months ago

I think the thesis of Pi is that there isn't much special about agents.

Model + prompt + function calls.

There are many such wrappers, and they differ largely on UI deployment/integration. Harness feels like a decent term, though "coding harness" feels a bit vague.

solarkraft4• 5 months ago

Can you shed some light on the speed difference of the direct integration vs. ACP?

I’m still looking for a generic agent interaction protocol (to make it worth building around) and thought ACP might be it. But (and this is from a cursory look) it seems that even OpenCode, which does support ACP, doesn’t use it for its own UI. So what’s wrong with it and are there better options to hopefully take its place?

rcarmo12• 5 months ago

Yeah, ACP adds another layer of marshaling/unmarshaling (or two-one on each side) and can be slower than API calls on occasion. Like MCP, it adds JSON overhead that doesn’t really need to be there.

The best option will always be in-memory exchanges. Right now I am still using the pi RPC, and that also involves a bit of conversion, but it’s much lighter.

ljm• 5 months ago

I've used ACP extensively because agent-shell in emacs uses it, although the Anthropic license change means I'm not sure if I can continue to use Claude through it without getting banned. I kind of wish it integrated more tightly but also you can't really expect someone to have magit involved such that agent-shell (or the like) starts interacting with emacs directly. I'd love it if it did though.

I've started using OpenCode for some things in a big window because its side-by-side diff is great.

infruset• 5 months ago

Note there is a fork oh-my-pi: https://github.com/can1357/oh-my-pi of https://blog.can.ac/2026/02/12/the-harness-problem/ fame. I use it as a daily driver but I also love pi.

himata41134• 5 months ago

Preconfigured PI: https://github.com/can1357/oh-my-pi

mijoharas• 5 months ago

I'd quite like the web tools from oh-my-pi, but able to be extracted to a normal pi tool or plugin... Maybe I should look into that sometime...

virtuallynathan• 5 months ago

Big fan of this fork, been using it for everything for the last couple of weeks.

Went from codex/claude code -> opencode -> pi -> oh-my-pi

esafak4• 5 months ago

Why not OpenCode?

jannniii2• 5 months ago

Oh-my-bloat.

I am still an avid user of opencode, my own fork though with async tools etc, but it is cumbersome and tries to do too many things.

jannniii2• 5 months ago

It is an awesome fork! Tried to contribute also, but community seems quite close knit.

amin2• 5 months ago

This looks great but It feels really risky to add more and more tools to the harness from random repos. Nothing against this repo in particular but I wish we had better security and isolation so I that I knew nothing could go wrong and I could just test a bunch of these every day the same way I can install an app on my phone and feel confident it's not going to steal my data.

e1g• 5 months ago

I test a bunch of these every day too, so I made a local sandbox to jail all TUI clunkers to $CWD and run all of them in —-yolo mode https://agent-safehouse.dev/

himata41134• 5 months ago

https://github.com/containers/bubblewrap

thepasch2• 5 months ago

I feel like this misses the point of pi somewhat. The allure of pi is that it allows you to start from scratch and make it entirely your own; that it’s lightweight and uses only what you need. I go through the list of features in this and I think, okay, cool, but why should I use this over OpenCode if I just want a feature-packed (and honestly -bloated) ready-made harness?

himata41134• 5 months ago

It's just better opencode while still being lightweight I don't know what else to say.

It's just an opinionated fork, either you like it or you don't. I personally really like it.

ge962• 5 months ago

Is that an official term "coding harness"

Wondering if you wanted a similar interface (though a GUI not just CLI) where it's not for coding what would you call that?

Same idea cycle through models, ask question, drag-drop images, etc...

rcarmo12• 5 months ago

LLM harness has been in vogue for a year now…

outofpaper• 5 months ago

A harness is a collection of stubs and drivers configured to assist with automation or testing. It's a standard term often used in QA as they've been automating things for ages before Gen Ai came on to the scene.

arcanemachiner2• 5 months ago

Yes. It seems to be the term that stands out the most, as terms like "AI coding assistant", "agentic coding framework", etc. are too vague to really differentiate these tools.

"harness" fits pretty nicely IMO. It can be used as a single word, and it's not too semantically overloaded to be useful in this context.

unshavedyak• 5 months ago

Honestly, i'm not interested in this if it can't use my subscription, but now i really want to understand this idea of coding harness. I've been exploring ideas that might be quite similar, though more inline with the scope of IDE, and it sounds like "coding harness" fits my mental model better.

ge962• 5 months ago

I'm not interested in coding myself as I like to write code still, I'm interested in that idea of task delegation eg. "research about this topic" or "do this". Having a bunch of agents doing things, that could be cool.

For me I'm looking to stick with Python so will whip something up with Tkinter later for the desktop GUI aspect although I still like Electron/JS primarily.

fred_tandemai2• 5 months ago

Anyone managed to run pi in a completely sandboxed environment? It can only access the cwd and subdirectories

fjk• 5 months ago

I’ve been tinkering with Gondolin, a micro-vm agent sandbox.

Here’s an example config: https://github.com/earendil-works/gondolin/blob/main/host/ex...

rcarmo12• 5 months ago

I run mine inside https://github.com/rcarmo/agentbox (with https://github.com/rcarmo/webterm)

monkey26• 5 months ago

I do this with an extension. I run all bash tools with bwrap and ACLs for the write and edit tools. Serves my purposes. Opens up access to other required directories, at least for git and rust.

I think I published it. Check the pi package page.

ac293• 5 months ago

Yeah I wrote a small landlock wrapper using go-landlock to sandbox pi that works well (not public, similar projects are landrun and nono).

Note that if you sandbox to literally just the working directly, pi itself wont run since pretty much every linux application needs to be able to read from /usr and /etc

carderne2• 5 months ago

I got pi to write me a very basic sandbox based on an example from the pi github. Added hooks for read/write/edit/bash, some prompts to temp/perm override. Have a look, copy-paste what you like.

https://github.com/carderne/pi-sandbox

ramoz3• 5 months ago

The way you’re able to extend the harness through extension/hook architecture is really cool.

Eg some form of comprehensive planning/spec workflow is best modeled as an extension vs natively built in. And the extension still ends up feeling “native” in use

mongrelion• 5 months ago

Pi ships with powerful defaults but skips features like sub-agents and plan mode

Does anyone have an idea as to why this would be a feature? don't you want to have a discussion with your agent to iron out the details before moving onto the implementation (build) phase?

In any case, looks cool :)

EDIT 1: Formatting EDIT 2: Thanks everyone for your input. I was not aware of the extensibility model that pi had in mind or that you can also iterate your plan on a PLAN.md file. Very interesting approach. I'll have a look and give it a go.

ramoz3• 5 months ago

See my comment in the thread but there is an intuitive extension architecture that makes integrating these type of things feel native.

https://github.com/badlogic/pi-mono/tree/main/packages/codin...

alvivar• 5 months ago

I plan all the time. I just tell Pi to create a Plan.md file, and we iterate on it until we are ready to implement.

jauntywundrkind3• 5 months ago

Agreed. I rarely find the guardrails of plan to be necessary; I basically never use it on opencode. I have some custom commands I use to ask for plan making, discussion.

As for subagents, Pi has sessions. And it has a full session tree & forking. This is one of my favorite things, in all harnesses: build the thing with half the context, then keep using that as a checkpoint, doing new work, from that same branch point. It means still having a very usable lengthy context window but having good fundamental project knowledge loaded.

miroljub2• 5 months ago

Check https://pi.dev/packages

There are already multiple implementations of everything.

With a powerful and extensible core, you don't need everything prepackaged.

mccoyb6• 5 months ago

Pi has made all the right design choices. Shout out to Mario (and Armin the OG stan) — great taste shows itself.

semiinfinitely• 5 months ago

I do not understand why in the age of ai coding we would implement this in javascript

Blackarea• 5 months ago

yes! I just don't understand that as well. Up until some time ago claud code's preferred install was a npm i, wasn't it? Please serious answers for why anyone would use a web language for a terminal app

mccoyb6• 5 months ago

It’s straightforward: JavaScript is a dynamic language, which allows code (for instance, code implementing an extension to the harness) to be executed and loaded while the harness is running.

This is quite nice — I do think there’s a version of pi’s design choices which could live in a static harness, but fully covering the same capabilities as pi without a dynamic language would be difficult. (You could imagine specifying a programmable UI, etc — various ways to extend the behavior of the system, and you’d like end up with an interpreter in the harness)

At least, you’d like to have a way to hot reload code (Elixir / Erlang could be interesting)

This is my intuition, at least.

sean_pedersen• 5 months ago

There is a Rust port: https://github.com/Dicklesworthstone/pi_agent_rust

moonlion_eth2• 5 months ago

i wrote an agent in zig, it kinda sucks tho. the language is just words

andai• 5 months ago

See also: pz: pi coding-agent in Zig

https://news.ycombinator.com/item?id=47120784

thomasfromcdnjs• 5 months ago

I am building an entire GPT model framework from the ground up in Typescript + small amounts of c bindings for gpu stuff. https://github.com/thomasdavis/alpha2 (using claude)

Don't hate me aha and no, there is no reason other than I can

KeplerBoy• 5 months ago

This confused me about openclaw for quite some time. The whole lobster/crustacean theme is just firmly associated with rust in my head. Guess it's just a claude/claw wordplay.

raincole5• 5 months ago

Thank god it's written in JavaScript. I might have skipped it if it were zig or something.

solarkraft4• 5 months ago

It’s one of the most productive languages and ecosystems (IMO top 1 over all).

rahimnathwani2• 5 months ago

Hugging Face now provides instructions for using local models in Pi:

https://x.com/victormustar/status/2026380984866710002

lukasb• 5 months ago

But I can't use my Codex plan with it, right? I have to use an API key?

mccoyb6• 5 months ago

You can use your Codex plan with it. OpenAI endorsed it several weeks ago, as far as I remember. That could change, however, but now seems safe.

ac293• 5 months ago

You can use your Claude or Gemini plan with it too for now, though Anthropic and Google have made it clear this is a ToS violation.

theshrike796• 5 months ago

Pi makes GPT-5.3-Codex act about on par with Claude easily.

There's something in the default Codex harness that makes it fight with both arms behind its back, maybe the sandboxing is overly paranoid or something.

With Pi I can one-shot many features faster and more accurately than with Codex-cli.

suralind• 5 months ago

I’ve been testing it for a few days on pretty much clean install (no customizations/extensions) and it’s ok. Not sure if I like it yet.

muratsu• 5 months ago

I’m working with a friend to build an ui around Pi to make it more user friendly for people who prefer to work with a gui (ala conductor). You can check out the repo: https://github.com/philipp-spiess/modern

ramoz3• 5 months ago

In the same spirit, I also ported a planning UI extension for Pi.

https://plannotator.ai/blog/plannotator-meets-pi/

elyase• 5 months ago

there is also pz a drop-in replacement for pi rewritten in Zig. 1.7MB static binary, 3ms startup, 1.4MB RAM idle. Find more at:

https://github.com/elyase/awesome-personal-ai-assistants?tab...

_neil• 5 months ago

Direct link to pz for those on mobile: https://github.com/joelreymont/pz

snthpy• 5 months ago

Cool, thanks for this. What about the extensions though? For me the point about pi is minimal base plus configurable extensions you choose.

mccoyb6• 5 months ago

Written by a person who is infamously annoying open source maintainers with AI slop PRs (see the DWARF debacle in OCaml) … and missing much of pi’s philosophy

Pass for me.

tmustier• 5 months ago

I haven’t met a single person who has tried pi for a few days and not made it their daily driver. Once you taste the freedom of being able to set up your tool exactly how you like, there’s really no going back.

and you can build cool stuff on top of it too!

ck_one• 5 months ago

What self-built capabilities do you like the most that claude code doesn't offer?

tomashubelbauer2• 5 months ago

Not the person you replied to, but I'll stress the point that it is not just what you can add that Claude Code doesn't offer, but also what you don't need to add that Claude Code does offer that you don't want.

I dislike many things about Claude Code, but I'll pick subagents as one example. Don't want to use them? Tough luck. (AFAIK, it's been a while since I used CC, maybe it is configurable now or was always and I never discovered that.)

With Pi, I just didn't install an extension for that, which I suspect exists, but I have a choice of never finding out.

theshrike796• 5 months ago

"hey, build a connector for z.ai GLM-5"

Can't do that with Claude =)

cudgy• 5 months ago

Claude code includes a large system prompt with every request while tool like pi does not. This could save tokens resulting in lower costs.

sshine2• 5 months ago

I haven’t met a single person who has tried pi for a few days and not made it their daily driver.

Pleased to meet you!

For me, it just didn’t compare in quality with Claude CLI and OpenCode. It didn’t finish the job. Interesting for extending, certainly, but not where my productivity gains lie.

esafak4• 5 months ago

People seem to be really enjoying rolling everything themselves these days...

ngrilly• 5 months ago

It sounds like it is the neovim or Emacs of coding agents.

PessimalDecimal• 5 months ago

I came here to say the same thing. It's basically _is_ Emacs. Heavily configurable tool, text-focused UI, primary interaction with a minibuffer ..er.. box to prompt at the bottom of the screen, package distribution mechanism, etc etc.

With Emacs modes like agent-shell.el available and growing, why not invest in learning a tool that is likely to survive and have mindshare beyond the next few months?

johanyc• 5 months ago

I've been using codex for about 2 months now and am pretty happy with it. What does pi do better than codex?

jsumrall• 5 months ago

If you ever want to use other models, pi can do that. In the middle of a session I might switch from gpt-5.2 to opus and get it to do something or review something and then switch back to gpt. Since models are being released every few weeks this is interesting to compare models without having to switch to a different harness.

And if there’s any feature codex has that you want, just have pi run codex in a tmux session and interrogate it how said feature works, and recreate it in pi.

thevinter• 5 months ago

Pi was probably the best ad for Claude Code I ever saw.

After my max sub expired I decided to try Kimi on a more open harness, and it ended up being one of the worst (and eye opening experiences) I had with the agentic world so far.

It was completely alienating and so much 'not for me', that afterwards I went back and immediately renewed my claude sub.

https://www.thevinter.com/blog/bad-vibes-from-pi

mccoyb6• 5 months ago

I would say that the project actively expects you to be downloading them to fill any missing gaps you might have.

Where did you get this perspective from?

I thought pi and its tools were supposed to be minimal and extensible. So why is a subagent extension bundling six agents I never asked for that I can’t disable or remove?

Why do you think a random subagents extension is under the same philosophy as pi?

Your blog post says little about pi proper, it's essentially concerned with issues you had with the ecosystem of extensions, often made by random people who either do or do not get the philosophy? Why would that be up to pi to enforce?

the_mitsuhiko2• 5 months ago

Sharing extensions is very much the philosophy. Using them however is less so.

Pi ships with docs that include extensions and the agent looks there for inspiration if you ask it to build a custom extension.

Looking at what others publish is useful!

NamlchakKhandro5• 5 months ago

hypegrift

CGamesPlay4• 5 months ago

if I start the agent in ./folder then anything outside of ./folder should be off limits unless I explicitly allow it, and the same goes for bash where everything not on an allowlist should be blocked by default.

Here's the problem with Claude Code: it acts like it's got security, but it's the equivalent of a "do not walk on grass" sign. There's no technical restrictions at play, and the agent can (maliciously or accidentally) bypass the "restrictions".

That's why Pi doesn't have restrictions by default. The logic is: no matter what agent you are using, you should be using it in a real sandbox (container, VM, whatever).

esafak4• 5 months ago

But the agent has to interact with the world; fetch docs, push code, fetch comments, etc. You can't sandbox everything. So you push that configuration to your sandbox, which is a worse UX that the harness just asking you at the right time what you'd like to do.

tern• 5 months ago

I had a very similar experience. I have different preferences, but ultimately, my takeaway was that if I want to follow my own version of their philosophy, I should just create my own thing.

In the meantime, the codex/cc defaults are better for me.

rcarmo12• 5 months ago

Paraphrasing The Dude, that’s like, just your opinion, man.

a96• 5 months ago

As it turns out, the opinions in question are that bash should be enabled by default with no restrictions, that the agent should have access to every file on your machine from the start, and that npm is the only package manager worth supporting.

Yep. This is why I've been going "Hell, no!" and will probably keep doing so.

raincole5• 5 months ago

Technically you're not allowed to use Claude subscription account with Pi (according to Anthropic's policy). So yeah, Pi is the best anti-ad against Anthropic.

isagawa-co• 5 months ago

Interesting approach to planning via extensions. I took a similar direction with enforcement. A governance loop that hooks into the agent's tool calls and blocks execution until protocol is followed. Every 10 actions (configurable), the agent re-centers. No permission popups, but the agent literally can't skip steps.

Open source: https://github.com/isagawa-co/isagawa-kernel

chriswarbo6• 5 months ago

I've been using pi via the pi-coding-agent Emacs package, which uses its RPC mode to populate a pair of Markdown buffers (one for input, one for chat), which I find much nicer than the awful TUIs used by harnesses like gemini-cli (Emacs works perfectly well as a TUI too!).

The extensibility is really nice. It was easy to get it using my preferred issue tracker; and I've recently overridden the built-in `read` and `write` commands to use Emacs buffers instead. I'd like to override `edit` next, but haven't figured out an approach that would play to the strengths of LLMs (i.e. not matching exact text) and Emacs (maybe using tree-sitter queries for matches?). I also gave it a general-purpose `emacs_eval`, which it has used to browse documentation with EWW.

dnouri2• 5 months ago

Nice! I'm curious to hear how you're mapping `read` and `write` to Emacs buffers. Does that mean those commands open those files in Emacs and read and write them there?

Let me also drop a link to the Pi Emacs mode here for anyone who wants to check it out: https://github.com/dnouri/pi-coding-agent -- or use: M-x package-install pi-coding-agent

We've been building some fun integrations in there like having RET on the output of `read`, `write`, `edit` tool calls open the corresponding file and location at point in an Emacs buffer. Parity with Pi's fantastic session and tree browsing is hopefully landing soon, too. Also: Magit :-)

chriswarbo6• 5 months ago

I've pushed the extension to GitHub at https://github.com/Warbo/pi-extensions/tree/master/extension...

The implementation is pretty terrible: a giant string of vibe-coded Emacs Lisp is sent to emacsclient, which performs the actions and sends back a string of JSON.

It's been interesting to iterate on the approach: watching the LLM (in my case Claude) attempting to use the tools; noticing when it struggles or makes incorrect assumptions; and updating the tool, documentation and defaults to better match those expectations.

I've also written some Emacs Lisp which opens Pi and tells it to "Action the request/issue/problem at point in buffer '<current-buffer>'" https://github.com/Warbo/warbo-emacs-d/blob/a13a1e02f5203476...

It feels similar to the file-watching provided by Aider (which uses inotify to spot files containing `# AI!` or `# AI?`), which I've previously used with FIXME and TODO comments in code; but it also works well in non-file things, e.g. error messages and test failures in `shell-mode`, and issues listed in the Emacs UI I wrote for the Artemis bug tracker (Claude just gets the issue number from the current line, and plugs that into a Pi extension I made for Artemis :-) )

type4• 5 months ago

What are people using to cost efficiently use this? I was using a Google Ultra sub which gave enough but that’s gone now.

ChatGPT $20/month is alright but I got locked out for a day after a couple hours. Considering the GitHub pro plus plan.

beacon294• 5 months ago

FWIW the lockout probably wasn't related... maybe the content you were working on or your context window management somehow triggered something?

lambda• 5 months ago

Qwen3 Coder Next in llama.cpp on my own machine. I'm an AI hater, but I need to experiment with it occasionally, I'm not going to pay someone rent for something they trained on my own GitHub, Stack overflow, and Reddit posts.

rahimnathwani2• 5 months ago

You could try minimax 2.5 via openrouter.

ursuscamp• 5 months ago

MiniMax has an incredibly affordable coding plan for $10/month. It has a rolling five hour limit of 100 prompts. 100 prompts doesn't sound like much, but in typical AI company accounting fashion, 1 prompt is not really 1 prompt. I have yet to come even close to hitting the limit with heavy use.

UncleOxidant2• 5 months ago

Run Qwen3-coder-next locally. That's what I'm doing (using LMstudio). It's actually a surprisingly capable model. I've had it working on some LLVM-IR manipulation and microcode generation for a kind of VLIW custom processor. I've been pleasantly surprised that it can handle this (LLVM is not easy) - there are also verilog code that define the processor's behavior that it reads to determine the microcode format and expected processor behavior. When I do hit something that it seems to struggle with I can go over to antigravity and get some free Gemini 3 flash usage.

kristianpaul4• 5 months ago

Same here

zirror• 5 months ago

What kind of hardware do you run it on?

raffkede2• 5 months ago

Kimi code with the .99 Cent plan is not to bad if you're savy

indigodaddy• 5 months ago

too bad I cannot star this.. https://github.com/badlogic/pi-mono/tree/main/packages/codin...

gtirloni2• 5 months ago

What's a coding harness? Claude Code is a "harness" and not a TUI?

ErikBjare• 5 months ago

If you run Claude Code with `-p --output-format json` it's no longer a TUI, but it's still a harness.

jasonjmcghee6• 5 months ago

The fact that it's a tui isn't particularly relevant. It could be a gui or cli and provide very similar value.

Nearly all of its value is facilitating your interaction with the LLM, the tools it can use, and how it uses them.

gtirloni2• 5 months ago

We used to call these "libraries".

qazplm17• 5 months ago

Pi treats you like an adult and shows whatever the fuck LLM is doing rather than actively hiding shit from the user. And just for that, once you tasted the freedom and transparency, there’s no way to go back to CC.

TZubiri2• 5 months ago

I think OpenCode is the same.

They are all open source though so you can just find out whats going on if you want right?

WXLCKNO• 5 months ago

After 2.20.0 of Claude code where they started not showing what files are read / searches are made by default .. I fucking love how easy it was to ditch Claude code for pi.

moonlion_eth2• 5 months ago

ive been using pi for about a week as daily driver and so far im happy with it. I really like the modular concept and also that its rather minimal

mobrienv• 5 months ago

Another batteries included pi setup. Built a lightweight mobile webui to run it on termux and code on my phone.

https://github.com/mikeyobrien/rho

rglover• 5 months ago

Excited to give this a try, looks really well done.

TZubiri2• 5 months ago

Wtf is that example gif?

The prompt shown is

"Who's your daddy and what does he do?"

Is this a joke or tech? Is the author a dev or a clown?

NamlchakKhandro5• 5 months ago

No one cares about your opinions.

This coding agent certainly couldn't give a fuck.

enneff• 5 months ago

It’s a quote from the movie Kindergarten Cop.

fnord77• 5 months ago

I mean using the captive agents is much cheaper than supplying your api key to a 3rd party agent.

CGamesPlay4• 5 months ago

To me, the most interesting thing about Pi and the "claw" phenomenon is what it means for open source. It's becoming passé to ask for feature requests and even to submit PRs to open source repos. Instead of extensions you install, you download a skill file that tells a coding agent how to add a feature. The software stops being an artifact and starts being a living tool that isn't the same as anyone else's copy. I'm curious to see what tooling will emerge for collaborating with this new paradigm.

axelthegerman• 5 months ago

And how great it will be to troubleshoot any issues because everyone is basically running a distinct piece of software

sshine2• 5 months ago

... made minutes ago.

wrxd• 5 months ago

I don’t want to be the one who has to upgrade this software + vibe coded patches.

It’s going to be very likely that once something is patched is to be considered as diverged and very hard to upgrade

theshrike796• 5 months ago

It's like the dude who monkey-patches their car and goes to the dealer to complain why the suspension is stiff.

It's because you put 2by4's in place of the shocks, you absolute muppet. And then they either give them a massive bill to fix it properly or politely show them out.

Same will happen in self-modifying software. Some people are self-aware enough to know that "I made this, it's my problem to fix", some will complain to the maker of the harness they used and will be summarily shown the door.

throwaway133373• 5 months ago

I see this happening, too.

We know that a lack of control over their environment makes animals, including humans, depressed.

The software we use has so much of this lack of control. It's their way, their branding, their ads, their app. You're the guest on your own device.

It's no wonder everyone hates technology.

A world with software that is malleable, personal, and cheap - this could do a lot of good. Real ownership.

The nerds could always make a home with their linux desktop. Now everyone can. It'll change the equation.

I'm quite optimistic for this future.

hdjrudni• 5 months ago

That's just because corporations got greedy and made their apps suck.

Strip away the ads, the data harvesting, add back the power features, and we'll be happy again. I'm more willing than ever to pay a one-time fee good software. I've started donating to all the free apps I use on a regular basis.

I don't want to own my own slop. That doesn't help me. Use your AI tools to build out the software if you want, but make sure it does a good job. Don't make me fiddle with indeterministic flavor-of-the-month AI gents.

h14h4• 5 months ago

I'm presently in the process of building (read: directing claude/codex to build) my own AI agent from the ground up, and it's been an absolute blast.

Building it exactly to my design specs, giving it only the tool calls I need, owning all the data it stores about me for RAG, integrating it to the exact services/pipelines I care about... It's nothing short of invigorating to have this degree of control over something so powerful.

In a couple of days work, I have a discord bot that's about as useful as chatgpt, using open models, running on a VPS I manage, for less than $20/mo (including inference). And I have full control over what capabilities I add to it in the future. Truly wild.

cedws2• 5 months ago

We’re off to a great start then with Anthropic banning users who use alternative clients with their Claude subscription.

GTP2• 5 months ago

The nerds could always make a home with their linux desktop. Now everyone can. It'll change the equation.

Probelm is, to be able to do what you're describing, you still need the source code and the permission to modify it. So you will need to switch to the FOSS tools the nerds are using.

CuriouslyC• 5 months ago

[flagged]

theshrike796• 5 months ago

Think of skills more like Excel macros (or any other software with robust macro support). It doesn't make sense for Microsoft to provide the specific workflow you need, but your own sheet needs it.

bandrami3• 5 months ago

a living tool that isn't the same as anyone else's copy

Yes, which is why this model of development is basically dead-in-the-water in terms of institutional adoption. No large firm or government is going to allow that.

raincole5• 5 months ago

Large institutions and governments had been pushing back against open source too until it became obviously inevitable.

lugao2• 5 months ago

Why would this new paradigm create interesting tooling? From your description I expect wrose not better tools.

vidarh2• 5 months ago

Worse it better for you when it meets your needs better.

I use a lot of my own software. Most of it is strictly worse both in terms of features and bugs than more intentional, planned projects. The reason I do it is because each of those tools solve my specific pain points in ways that makes my life better.

A concrete example: I have a personal dashboard. It was written by Claude in its entirety. I've skimmed the code, but no more than that. I don't review individual changes. It works for me. It pulls in my calendar, my fitbit data, my TODO list, various custom reminders to work around my tendency to procrastinate, it surfaces data from my coding agents, it provides a nice interface for me to browse various documentation I keep to hand, and a lot more.

I could write a "proper" dashboard system with cleanly pluggable modules. If I were to write it manually I probably would because I'd want something I could easily dip in and out of working on. But when I've started doing stuff like that in the past I quickly put it aside because it cost more effort than I got out of it. The benefit it provides is low enough that even a team effort would be difficult to make pay off.

Now that equation has fundamentally changed. If there's something I don't like, I tell Claude, and a few minutes - or more - later, I reload the dashboard and 90% of the time it's improved.

I have no illusions that code is generic enough to be usable for others, and that's fine, because the cost of maintaining it in my time is so low that I have no need to share that burden with others.

I think this will change how a lot of software is written. A "dashboard toolkit" for example would still have value to my "project". But for my agent to pull in and use to put together my dashboard faster.

A lot of "finished products" will be a lot less valuable because it'll become easier to get exactly what you want by having your agent assemble what is out there, and write what isn't out there from scratch.

redfloatplane2• 5 months ago

I've been thinking about this lately too. I think we're going to see the rise of Extremely Personal Software, software that barely makes any sense outside of someone's personal context. I think there is going to be _so_ much software written for an audience of 1-10 people in the next year. I've had Claude create so much tooling for me and a small number of others in the last few months. A DnD schedule app; a spoiler-free formula e news checker; a single-use voting site for a climbing co-op; tools to access other tools that I don't like using by hand; just absolutely tons of stuff that would never have made any sense to spend time on before. It's a new world. https://redfloatplane.lol/blog/14-releasing-software-now/

boh• 5 months ago

I think people overestimate the general population's ability and interest in vibe coding. Open source tools are still a small niche. Vibe code customized apps are an even bigger niche.

thierrydamiba• 5 months ago

I actually look at this another way. I think we’re going to see a lot more open source. Before you had to get your pr merged into main. Now people will just ask ai to build the tool they need and then open source it.

Maintainers won’t have to deal with an endless stream of PRs. Now people will just clone your library the second it has traction and make it perfect for their specific use case.

Cherry pick the best features and build something perfect for them. They’ll be able to do things your product can’t, and individual users will probably find a better fit in these spinoffs than in the original app.

rbren• 5 months ago

Funny, I just released my dev setup as “Open prompt”

https://github.com/rbren/personal-ai-devbox

GTP2• 5 months ago

It's becoming passé to ask for feature requests and even to submit PRs to open source repos.

Yet, the first impact on FOSS seems to be quite the opposite: maintainers complaining about PRs and vulnerability disclosures that turn out to be AI hallucinations, wasting their time. It seems to be so bad that now GitHub is offering the possibility of turning off pull requests for repositories. What you present here is an optimistic view, and I would be happy for it to be correct, but what we've seen so far unfortunately seems to point in a different direction.

brandensilva2• 5 months ago

We might be witnessing some survivor bias here based on our own human conditioning. Successful PRs aren't going to make the news like the bad ones do.

With that said, we are all dealing with AI still convincingly writing code that doesn't work despite passing tests or introducing hard to find bugs. It will be some time until we iron that out fully for more reliable output I suspect.

Unfortunately we won't be able to stop humans thinking they are software engineers when they are not now that the abstraction language is the human language so guarding from spam will be more important than ever.

davej• 5 months ago

Patrick Collison said this yesterday on TBPN, "Software is becoming like pizza […] It should be cooked right then and there at the moment of use"

dTal• 5 months ago

  Is it possible that software is not like anything else, that it is meant to be discarded: that the whole point is to always see it as a soap bubble?

  --Alan Perlis

giancarlostoro• 5 months ago

Instead of extensions you install, you download a skill file that tells a coding agent how to add a feature. The software stops being an artifact and starts being a living tool that isn't the same as anyone else's copy. I'm curious to see what tooling will emerge for collaborating with this new paradigm.

I build my own inspired by Beads, not quite as you're describing, but I store todo's in a SQLite database (beads used SQLite AND git hooks, I didn't want to be married to git), and I let them sync to and from GitHub Issues, so in theory I can fork a GitHub repo, and have my tool pull down issues from the original repo (havent tried it when its a fork, so that's a new task for the task pile).

https://github.com/Giancarlos/guardrails/issues

You can see me dogfeeding my tool to my tools codebase and having my issues on the github for anyone to see, you can see the closed ones. I do think we will see an increase in local dev tooling that is tried and tested by its own creators, which will yield better purpose driven tooling that is generic enough to be useful to others.

I used to use Beads for all my Claude Code projects, now I just use GuardRails because it has safety nets and works without git which is what I wanted.

I could have forked Beads, but the other thing is Beads is a behemoth of code, it was much easier to start from nothing but a very detailed spec and Claude Code ;)

brandensilva2• 5 months ago

I totally feel this. Prior I never had time for doing this but now I just do it without even thinking about contributing.

20022026• 5 months ago

Anyone tried pi with 5.3-codex vs codex cli?

rcarmo12• 5 months ago

I run it almost exclusively with codex models. Zero issues.

TacticalCoder• 5 months ago

Naming skills though...

ianlpaterson3• 5 months ago

Coming from OpenClaw, it's pretty amazing how fast pi is, particularly paired with Qwen3 that dropped today. It's a magical time.

kristianpaul4• 5 months ago

Indeed, it seems to just works with a self hosted Qwen3 coder next.

ianlpaterson3• 5 months ago

yes!

jasonjmcghee6• 5 months ago

What dropped today? Wasn't Qwen3 Coder Next released beginning of the month?

Qwen3.5 released a couple of days ago but I'm not that RAM rich

breisa• 5 months ago

Alibaba released a whole set of new Qwen 3.5 models including a ~120B and a ~35B MoE.

buremba5• 5 months ago

I spent 3 months adopting Codex and Claude Code SDKs only to realize they're just vendor lock-in and brittle. They're intended to be used as CLI so it's not programmable enough as a library. After digging into OpenClaw codebase, I can safely say that the most of its success comes from the underlying harness, pi agent.

pi plugins support adding hooks at every stage, from tool calls to compaction and let you customize the TUI UI as well. I use it for my multi-tenant Openclaw alternative https://github.com/lobu-ai/lobu

If you're building an agent, please don't use proprietary SDKs from model providers. Just stick to ai-sdk or pi agent.

siva7• 5 months ago

I also wondered for months why it feels so difficult to use Openai or Anthropic SDKs until i came to a similar conclusion.

bjackman• 5 months ago

IIUC to reliably use 3P tools you need to use API billing, right? Based on my limited experimentation this is an order of magnitude more expensive than consumer subscriptions like Claude Pro, do I have that right?

("Limited experimentation" = a few months ago I threw $10 into the Anthropic console and did a bit of vibe coding and found my $10 disappeared within a couple of hours).

If so, that would support your concern, it does kinda sound like they're selling marginal Claude Code / Gemini CLI tokens at a loss. Which definitely smells like an aggressive lockin strategy.

buremba5• 5 months ago

Technically you're still using claude CLI with this pattern so it's not 3P app calling Anthropic APIs via your OAuth token. Even if you would use Claude Code SDK, your app is 3P so it's in a gray area.

Anthropic docs is intentionally not clear about how 3P tools are defined, is it calling Claude app or the Anthropic API with the OAuth tokens?

vanillameow2• 5 months ago

Unfortunately it's currently very utopian for (I would assume) most devs to use something like this when API cost is so prohibitively expensive compared to e.g. Claude Code. I would love to use a lighter and better harness, but I wouldn't love to quintuple my monthly costs. For now the pricing advantage is just too big for me compared to the inconvenience of using CC.

buremba5• 5 months ago

You technically still use CC, it's not via SDK but via CLI programmatically triggered via pi.

badlogic3• 5 months ago

OpenAI officially supports using your subscription with pi. Same for OpenCode and other 3rd party harnesses.

kzahel• 5 months ago

I left some notes about this. I agree with you directionally but practically/economically you want to let users leverage what they're already paying for.

https://yepanywhere.com/subscription-access-approaches/

Captures the ai-sdk and pi-mono.

In an ideal world we would have a pi-cli-mono or similar, like something that is not as powerful as pi but gives a least common denominator sort of interface to access at least claude/codex.

ACP is also something interesting in this space, though I don't honestly know how that fits into this story.

buremba5• 5 months ago

Page returns 404. ACP is great, indeed better to give pi-mono ACP than claude or codex directly. https://x.com/bu7emba/status/2026364497527513440

burgerquizz• 5 months ago

how do you replicate the claude code system prompts in pi? i have tried using claude agebt sdk without the claude code preset, and it is quite bad

Munksgaard• 5 months ago

Pretty easy, the prompts can be seen here[0] and pi supports setting SYSTEM.md.

0: https://cchistory.mariozechner.at/

reacharavindh3• 5 months ago

I began with pi, and have been using oh-my-pi the last two weeks.

https://github.com/can1357/oh-my-pi

More of a batteries included version of pi.

self_awareness2• 5 months ago

Are you running it in some kind of sandbox? Does it have sandboxing features?

reacharavindh3• 5 months ago

I dont. I use this as my coding harness (replacement of gemini-cli/claudecode etc). I dont want to sandbox it because I expect it to be used only for coding on projects. I dont want to over complicate it.

I am building my own assistant as an AI harness - that is definitely getting sandboxed to run only as a VM on my Mac.

neop1x2• 5 months ago

I use a sandbox example extension with comes with Pi, it uses the anthropic sandbox runtime (bubblewrap on linux). The runtime has one bug and needs one improvement (I've made PRs, no response yet). Pi's sandbox example extension does not block internal tools (read/write) according to rules, I've created a PR but can't submit because of Pi's OSS vacation BS... https://github.com/badlogic/pi-mono/compare/main...k3a:pi-mo... I am quite happy with my patched forks for now

mr_o472• 5 months ago

How’s your experience so far with oh my pi

reacharavindh3• 5 months ago

A few things. I intentionally clone the repo and build it locally for my use and use it as my-omp.. this way, I can make oh-my-pi make customisations like skills, tools, anything and yet retain the ability to do a git pull from upstream with cherry picking if necessary.

I have this in my shell rc.

   # bun

   export BUN_INSTALL="$HOME/.bun"

   export PATH="$BUN_INSTALL/bin:$PATH"

   alias my-omp= "bun/Users/aravindhsampathkumar/ai_playground/oh-my-pi/packages/coding-agent/src/cli.ts"

and do

1. git pull origin main

2. bun install

3. bun run build:native

every time I pull changes from upstream.

Until yesterday, this process was purely bliss - my own minimal custom system prompt, minimal AGENTS.md, and self curated skills.md. One thing I was wary of switching from pi to oh-my-pi was the use of Rust tools pi-native using NAPI. The last couple of days whatever changes I pulled from upstream is causing the models to get confused about which tool to use and how while editing/patching files. They are getting extremely annoyed - I see 11 iterations of a tool call to edit a damn file and the model then resorted to rewriting the whole file from memory, and we al know how that goes. This may not be a bug in oh-my-pi per se. My guess is that the agent developed its memory based on prior usage of the tools and my updating oh-my-pi brought changes in their usage. It might be okay if I could lose all agent memory and begin again, but I dont want to.

I'm going to be more diligent about pulling upstream changes from now on, and only do when I can afford a full session memory wipe.

Otherwise, the integrations with exa for search, LSP servers on local machine, syntax highlighting, steering prompts, custom tools (using trafilatura to fetch contents of any url as markdown, use calculator instead of making LLM do arithmetic) etc work like a charm. I haven't used the IPython integration nor do I plan to.

thepasch2• 5 months ago

Stop advertising pi, people. It _somehow_ continued to fly somewhat under the radar after that whole OpenClaw nonsense. Don’t make Anthropic’s sic their bloodhounds on them like they did on OpenCode.

tietjens2• 5 months ago

pi is an officially accepted harness of either Anthropic or OpenAI. I forgot which.

raincole5• 5 months ago

Interestingly, since OpenClaw, there has been ~one post about Pi every week. But practically no one voted any of them except this one.

kristianpaul4• 5 months ago

People deserve to know it exists, I got tired of even OpenCode workflows/agents, installed OpenSpec but all this wrapped todos still not how i wanted I needed more control but dint wanted to write my own tool, then i ended knowing about pi, this got me interested at first read:

No plan mode. Write plans to files, or build it with extensions, or install a package. No built-in to-dos. Use a TODO.md file, or build your own with extensions. No background bash. Use tmux. Full observability, direct interaction.

This is very important to have control and ownership.

Pi is not for everyone, but the ones eventually want to have tools like (read, bash, edit, write, grep, find, ls) as building blocks.

mr_o472• 5 months ago

I recently discovered this via a YouTube video a few days ago

I really like the customization aspect of it and you can build tools on fly and even switch model mid session

There’s another project here called oh my pi has anyone here tried it

raffkede2• 5 months ago

it even runs inside a browser I'll publish my browserpi if someone is interested I did not dare to add a pull request with my slop but i would love to show the fork and create a pull request if there is broader interest

vinibrito• 5 months ago

No need to push to normal repo, just publish your fork, I'd like to see it

sheerun• 5 months ago

This domain must have costed $$$$

thomascountz• 5 months ago

   pi.dev domain graciously donated by exe.dev

Notwithstanding the donation, this domain must have costed $$$$

solarkraft4• 5 months ago

I happen to be somewhat familiar with OpenCode and am considering using it as a personal AI workspace (some chat & agentic behavior, not worrying about initiative behavior just yet, I’d try to DIY memory with local files and access to my notes) because it seems to have a decent ecosystem.

Pi appears to have a smaller, less “pre-made” ecosystem, but with more flexibility, enthusiasm and extensibility.

Is this correct? Should I look towards Pi over OpenCode? What are the UI options?

amunozo2• 5 months ago

I have the same question as you, but I want to add that I used OpenCode for general tasks like writing, organization and such but with a context of .md files and it works wonders. And like you, I am considering trying a better suited harness for this task.

solarkraft4• 5 months ago

What issues are you facing with OpenCode?

I looked a bit into the reasoning for Pi’s design (https://mariozechner.at/posts/2025-11-30-pi-coding-agent/#to...) and, while it does seem to do a lot of things very well around extensibility, I do miss support for permissions, MCP and perhaps Todos and a server mode. OpenCode seems a lot more complete in that regard, but I can well imagine that people have adapted Pi for these use cases (OpenClaw seems to have all of these). So it’s definitely not out of the race yet, but I still appreciate OpenCodes relative seeming completeness in comparison.

mritchie712• 5 months ago

I think you're reading it exactly right

mikodin• 5 months ago

I've been using PI for this - just switch to "oh my pi" and am liking it!

Honestly, it's been a dream, I have it running in a docker-sandbox with access to a single git repo (not hosted) that I am using for varied things with my business.

Try it out, it's super easy to setup. If you use docker sandbox, you can just follow what is necessary for claude, spin up the sandbox, exit out, exec into it with bash and switch to Pi.

carderne2• 5 months ago

The people pushing oh-my-pi seem to have missed the point of pi... Downloading 200k+ lines of additional code seems completely against the philosophy of building up your harness, letting your agent self-improve, relying on code that you control.

If you want bags of features, rather clone oh-my-pi somewhere, and get your agent to bring in bits of it a time, checking, reviewing, customising as you go.

manojlds• 5 months ago

Yeah ohmypi is garbage. The point is you have a thing shell and add your own on top by just talking to pi itself or pick in selective extensions.

_pdp_2• 5 months ago

I still don't get why would you want to use a terminal app to code when you can do all of this through IDE extension which does the same except it is better integrated.

You can open a grid of windows inside vscode too and it comes back up exactly as it was on reload.

theshrike796• 5 months ago

When I use a CLI agent to code, I don't need the IDE for anything.

Think of it more like directing a coworker or subcontractor via text chat. You tell them what you want and get a result, then you test it if it's what you want and give more instructions if needed.

I literally just fixed a maintenance program on my own server while working my $dayjob. ssh to server, start up claude and tell it what's wrong, tab away. Then I came back some time later, read what it had done, tested the script and immediately got a few improvement ideas. Gave them to Claude, tabbed out, etc.

Took me maybe 15 minutes of active work while chatting on Slack and managing my other tasks. I never needed to look at the code at any point. If it works and tests pass, why do I care what it looks like?

_pdp_2• 5 months ago

I suppose we are working on different problems.

In my own experience I cannot blindly accept code without even looking at it even for a few moments because I've had many situations where the code was simply doing the wrong things... including tests are completely wrong and testing the wrong assumptions.

So yah, even when I review trivial changes I still look at the diff view to see if it makes sense. And IDEs make code review a lot easier than diff.

Btw, this experience is not from lack of trying. We use coding agent extensively (I would assume more than the typical org looking at our bill) and while they are certainly very, very helpful and I cannot describe how much effort they are really saving us, there is absolutely zero chance of pushing something out without reviewing it first - same applies for code written by AI agent or a coworker.

chriswarbo6• 5 months ago

I still don't get why would you want to use a terminal app to code when you can do all of this through IDE extension which does the same except it is better integrated.

I agree. I tried Gemini CLI for a while, and didn't like how separate I felt from the underlying files: rather than doing minor cleanup myself, the activation energy of switching to a separate editor and opening the same files was too high, so I'd prompt the LLM to it instead. Which was often an exercise in frustration, as it would take many rounds of explanation for such tiny payoffs; maybe even fiddling with system prompts and markdown files, to try and avoid wasting so much time in the future...

I've been using Pi for a few weeks now, and have managed to integrate it quite deeply into Emacs. I run it entirely via RPC mode (JSON over stdio), so I don't really know (or care) about its terminal UI :-)

BeetleB• 5 months ago

I still don't get why would you want to use a terminal app to code when you can do all of this through IDE extension which does the same except it is better integrated.

Because then you need to make an extension for every IDE. Isn't it better to make a CLI tool with a server, and let people make IDE extensions to communicate with it?

Claude Code has an update every few days. Imagine now propagating those changes to 20+ IDEs.

rubenflamshep• 5 months ago

I've found VSCode _ok_ to work with across across different workspaces/projects. The window memory is hit and miss. There's a secondary side bar I've been trying to NOT have open on startup but always seem to stick around. I'd prefer to programmatically manage the windows so I can tinker with an automated setup but the VSCode API/Plugins for managing this are terrible and tend to fail silently.

CLI within VSCode is workable but most of my VSCode envs are within a docker container. This is a pattern that I'm moving more and more away from as agents within a container kind of suck.

alabhyajindal• 5 months ago

I am also going to now implement an existing project and invent a different name for it. Look out for Waterfox, a minimal web consumer.

bankombinator• 5 months ago

Mario mentioned in hackernews.

squeefers3• 5 months ago

minimal indeed. why are we regressing back to terminals now? ive seen this in the rust world mainly

jacobgorm• 5 months ago

Some of us never left the terminal. Welcome to the future.

chriswarbo6• 5 months ago

Doesn't need a terminal: run it in RPC mode to send/receive JSON over stdio. That's how the pi-coding-agent Emacs package works, which is the only way I've ever used Pi.

It seems pretty well done: when I added permission requests to the `bash` tool, the "Are you sure y/N" requests started appearing just like they were native to Emacs.

nacozarina• 5 months ago

too many things named ‘pi’, kmn

Veen• 5 months ago

Its original name was more distinctive but less "enterprise friendly".

https://shittycodingagent.ai

chid• 5 months ago

interestingly that's what comes up when you search for pi-coding-agent rather than the new domain.

twsted• 5 months ago

I do not understand some of the comments here: openclaw uses pi.

It seems stange also that even Steinberger in his interviews is not giving pi the proper attribution.

Vegenoid• 5 months ago

What models are you all using with Pi? How much are you paying on monthly or weekly basis for your usage? I'm very interested in it, but my budget is constrained and the usage granted by a $20/month Claude plan seems much more affordable than when I've tried API-based access with other agents. Unfortunately, this locks me in to Claude Code.

neop1x2• 5 months ago

Use OpenRouter, lots of great open-weights models like MiniMax, Kimi K2, Mistral, Qwen, ...

nebben64• 5 months ago

so are people pairing OpenRouter with open agent harnesses like Pi or OpenCode?

kristianpaul4• 5 months ago

Qwen3 coder next works very well. I started with 20usd/month ollama cloud and switch to 200usd then decided host my own llm with a gigabyte ai atop since now i'm using llms agents everywhere on my home lab

NamlchakKhandro5• 5 months ago

100% this is where OpenCode missed the boat.

PI is what it looks like when you treat your Plugin sdk as the golden path

Pi – A minimal terminal coding harness

Related Stories