Pi.dev is a landing page for a minimal, extensible terminal coding agent designed to empower users through customization and control. The content advocates for user autonomy, freedom of information access through multi-provider support, and participation in technical culture via open-source licensing and community-driven packages. However, structural accessibility barriers documented in the DCP limit participation for disabled users and non-technical audiences.
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.
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).
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.
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.
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.
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.
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.
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?
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.
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.
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.
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.
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).
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 :-)
> 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.
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.
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.
> 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.
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.
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?
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?
Core philosophy emphasizes cultural and technological participation: 'Pi is aggressively extensible so it doesn't have to dictate your workflow.' Extensibility enables participation in cultural life of community. Context engineering and customization reflect respect for creative expression.
FW Ratio: 50%
Observable Facts
Philosophy states 'Pi is aggressively extensible so it doesn't have to dictate your workflow. Features that other tools bake in, you can build yourself.'
MIT License with 'Mario Zechner & contributors' attribution.
'Bundle extensions, skills, prompts, and themes as packages. Install from npm or git.'
Footer states 'pi.dev domain graciously donated by exe.dev ❤️' showing community stewardship.
Core philosophy emphasizes extensibility and user control: 'Features that other tools bake in, you can build yourself.' Extensibility enables freedom to seek, receive, impart information and ideas. Context engineering section frames user control over information flow.
FW Ratio: 50%
Observable Facts
Page states 'Pi ships with powerful defaults but skips features' enabling user-built customization of information handling.
Documentation states '15+ providers, hundreds of models' with ability to 'Switch models mid-session with /model or Ctrl+L.'
'/export' and '/share' features documented for information dissemination.
Free npm installation with no account requirement.
Inferences
Multiple model provider support and mid-session switching operationalizes freedom to seek and access diverse information sources.
Export and share features enable freedom to impart information to others.
Aggressively extensible design philosophy reflects commitment to user control over information and ideas.
Cached DCP access_model modifier (+0.12) reflects free open-source distribution removing barriers to information access.
Freedom of movement framed implicitly through 'navigate to any previous point' in session trees; context control emphasizes user agency in information access.
FW Ratio: 50%
Observable Facts
Page describes '/tree to navigate to any previous point and continue from there.'
Export to HTML and share to GitHub gist features documented.
Inferences
Session navigation feature operationalizes freedom of movement through information space.
Export and share capabilities support freedom to move ideas between contexts.
Content emphasizes human dignity through autonomy and extensibility philosophy; promotes user agency and self-determination in workflow design. Frames technology as servant to human purposes, not master.
FW Ratio: 60%
Observable Facts
Page states 'Adapt pi to your workflows, not the other way around,' emphasizing user autonomy.
MIT License attribution visible with contributor credits.
No WCAG compliance indicators or accessibility features documented on-domain.
Inferences
Emphasis on adaptability and extensibility reflects commitment to respecting diverse human needs and preferences.
Free open-source model structurally enables broader participation, though undocumented accessibility gaps may exclude disabled users from that participation.
Community emphasis and Discord server reflect freedom of association commitment. Philosophy section framing of extensibility implies support for collaborative assembly.
FW Ratio: 50%
Observable Facts
Page lists 'Discord: Community server for discussion and sharing' and 'Issues: GitHub for bugs and features.'
50+ example packages and community-contributed packages encourage collaborative assembly.
'Find packages on npm or Discord. Share yours with the pi-package keyword.'
Inferences
Multiple communication channels (Discord, GitHub) enable freedom of association and assembly.
Open package ecosystem operationalizes right to associate through collaborative contribution.
Encouragement to share packages reflects normalization of peaceful assembly for shared purposes.
Extensibility and customization philosophy enable education and development of personality and talents: 'Features that other tools bake in, you can build yourself.' Skills and prompt templates support learning and capability development.
FW Ratio: 57%
Observable Facts
Page documents 'Skills: Capability packages with instructions and tools, loaded on-demand.'
Prompt templates described as 'Reusable prompts as Markdown files.'
50+ examples and community packages provide learning resources.
No explicit health or welfare framing in documentation.
FW Ratio: 50%
Observable Facts
Cached DCP reports 'No WCAG compliance indicators, alt text, or accessibility statements visible; interactive elements present without documented accessibility features.'
Installation and use require command-line proficiency.
Inferences
Absence of accessibility documentation and features creates structural barriers to health-related or welfare-related use by disabled users.
Technical complexity may exclude users who need simpler interfaces for wellbeing-related workflows.
Open-source with MIT license and transparent attribution (cached DCP: +0.05 and +0.08 modifiers) enable participation in cultural/technical commons. Free npm distribution (cached DCP: +0.12) removes access barriers. Package ecosystem and 50+ examples enable contribution to shared technical culture. Export and share features enable creative dissemination. No documented restrictions on participation.
Free open-source access (cached DCP: +0.12 modifier for 'low barrier to access and modification'). npm and GitHub distribution, no paywall. Documentation and examples enable information access. 15+ provider support and model switching (Ctrl+L, Ctrl+P) enable access to diverse information sources. Export and share features enable information dissemination.
GitHub issues, Discord community server, and package ecosystem structurally enable freedom of association and peaceful assembly. No documented restrictions on community participation.
Tree-structured sessions with navigation (/tree command) and export/share features enable freedom of movement through information history. No documented geographic or content restrictions.
Open-source distribution with MIT license and transparent attribution supports collaborative human dignity. Free access model removes barriers but site lacks accessibility features for disabled users.
Skills system, prompt templates, and extensive documentation enable self-directed learning. Examples and community packages provide educational resources. However, accessibility gaps (cached DCP: -0.05) limit education access for disabled users.
No accessibility features documented (cached DCP: -0.05 modifier 'No WCAG compliance indicators, alt text, or accessibility statements visible'). High technical barrier excludes users with disabilities and non-technical users.
Free, open-source, no-tracking model (cached DCP: 'No tracking pixels or advertising observed') respects privacy; sessions shareable only when user explicitly opts via /share; no mandatory telemetry documented.
Open-source model with transparent authorship (Mario Zechner & contributors) and MIT license supports intellectual property rights through attribution and licensing clarity.
Open-source, transparent design and documentation support social order and public order enabling free expression and association. No documented anti-democratic features.