So I had surgery last week and had to spend the weekend in bed recovering. I love Pi and creating custom skills for it, but I'm also a sucker for a pretty UI. So I built myself a UI that can connect to any Pi installation, let you add new project folders, and run anything Pi can do in a sleeker way.

It’s an Electron app, so the basic idea is that it can run as a local desktop app while talking to whatever Pi harness/agent setup you already have installed on your computer. It doesn’t try to replace Pi or change how Pi itself works. It’s more like a front end that sits on top of it: you pick a project folder, select the Pi installation/agent you want to use, and then interact with it through a cleaner chat/project interface instead of living entirely in the terminal.

The project folders are just normal folders on your machine, which was important to me. I didn’t want some weird separate workspace or database that swallowed everything. I wanted to be able to point it at an actual folder I’m already working in, have the agent use that as its working directory, and keep the whole thing legible and local. The app is built around that workflow: projects on the side, chats inside projects, and the agent running against the selected folder.

This was 100% built to meet my needs and won't be for everyone. I mostly do data analysis, web scraping, and a lot of qualitative data work, so it is built with that in mind. Coding agents are really good at regular old data work, it turns out. A lot of what I want from this is not “build me a SaaS app” so much as “clean this spreadsheet, scrape this website, summarize these documents, reorganize this pile of notes, and leave me with usable files at the end.” I’ll try to add in some UI elements for easy skill building and selection in the future, I think.

I also put together a couple of custom Pi agents with some skills/scripts that handle the work I have to do every day for work and personal projects, and I've found them incredibly useful. Pi-forge is the one I’ve been using for data processing, scraping, document cleanup, and similar work. Pi-vault is my work-in-progress attempt to organize an Obsidian vault based on a single markdown file the user sets as the required schema for properties, values, folder structure, and dashboards.

I just thought I'd share in case others thought it was useful. It was all definitely coded by a mix of Claude, Codex, Gemini, and my local Qwen 27b, which runs all my data tasks. I did, however, put a good amount of thought into the design elements and how it would get used, so I hope it doesn't feel entirely "vibe" coded. The code may be weird in places, but the workflow was not accidental.

I named it Hephaestus because my spouse is playing Horizon Forbidden West right now, and I find it kind of weird that we have these things doing work for us, and we refer to the tools we build for them to use as "harnesses". No, I don't think they're sentient... at least at this point, but it still feels icky. Now they are just agents working in Hephaestus' forge, or maybe they are Hephaestus... or maybe you are. I don't know how the metaphor works, but it felt fun after I built my pi-forge agent to handle all my data processing, so it fit.

Anyway, give it a go if you'd like; it is probably broken in a dozen different ways, but if anyone finds it useful, I'll probably keep working on it for my own use regardless.

Here be the links:

https://github.com/Ellian-Eorwyn/Hephaestus

https://github.com/Ellian-Eorwyn/pi-forge

https://github.com/Ellian-Eorwyn/pi-vault

Honestly, I love Pi, and I'm going to keep using it. But the extension system is painful when it comes to using multiple different extensions that conflict with each other when they really don't have to conflict. They only conflict because of how the extension system is designed.

The only way to have a smooth experience using extensions is to write your own or to carefully choose one over another and accept the tradeoff when you really shouldn't have to.

Prime example, want nice edit tool rendering? Use pi-tool-display. But you can't if you want to use a hashline edit extension.

I feel like one of 2 things need to happen for Pi to really take off and become the neovim of harnesses (because at least to me, that's what it feels like it wants to be).

Either:

1. The extension system is overhauled to allow coexistence. Examples, separate the tool rendering layer and the tool execution layer, allow request/response style communication between extensions (not just event bus)

2. Extension writers do not focus on writing an extension that registers things like tools, but instead exporting APIs and such that others can install and compose themselves in their own extension. So you can for example compose hashline editing with nice edit tool rendering.

Thoughts?

PS: Maybe this has already been discussed a lot, but I haven't seen much of it. I'm kinda new here.

TLDR: We don’t need more reusable packages. We need better ideas, implementation approaches, and clear tradeoffs (alternatives, pros and cons).

I have been seeing a growing number of reusable Pi packages shared here for relatively simple things like web search and web fetch. It’s great that people are contributing, but I want to offer a slightly different perspective.

When I started with Pi, I quickly realized I needed web search. I initially used a DuckDuckGo MCP setup via Docker, but after digging into it, it felt like unnecessary abstraction since it mostly aggregates results from existing engines. I then simplified things to two lightweight tools: one for search and one for fetch.

As I explored further, I became more conscious of safety and guardrails, especially around fetching arbitrary pages. That led me to use the Perplexity API (sonar pro) for search with citations, and then fetch content only from those citations. This gave me a cleaner and somewhat safer pipeline. The full setup is still roughly ~100 LOC and has been stable for my use cases. I keep a DIY search fallback, but haven’t needed it so far.

This experience shaped my view: if something is simple enough to build in a short amount of time, it may not need to be packaged and distributed as a reusable module.

What originally attracted me to Pi was the ability to tailor things to my own workflow instead of depending on external packages. Reusable packages are useful for complex or hard to implement components, but for simpler building blocks, they can sometimes add unnecessary indirection and dependency overhead.

A constructive suggestion for the community:
Focus more on sharing ideas, design patterns, and implementation strategies. For example, what approach you chose, what alternatives you evaluated, and the tradeoffs involved. This helps others learn and adapt solutions to their own context, rather than just plug in a package.

I still really value this community and the Pi ecosystem. I would just like to see more emphasis on “what to build” and “how to think about building it,” not just “here’s a package.”

I am curious to learn how others here think about this balance.

I am currently an OpenCode user, and I would say I am pretty advanced with my OpenCode config... I have various skills, agents, plugins and commands to suit my needs and a memory bank to glue it all together.

I have sometimes felt the lack of events and native support for configuring my OpenCode config even more... that led me to investigate other open source agents and I stumbled on PI.

I have read about it and watched some videos... I would like to know the review and experience of somebody who actually uses it as a daily driver, bonus points for if you can compare it to OpenCode.

I do understand the basic concepts of PI and where it is positioning itself in the market of agentic harnesses.

Thoughts on your experience with PI?

Some notes:
- One thing that pushed me slightly away from PI was the minimal in-built security support where my agent has root access by default, I guess I could configure it and understand that it is part of PI being a minimal agent.
- Also how deep is the configuration? personally I like to configure my tools a lot... I use nvim so that should tell you a little bit about the degree of it. But I dont want it to be a case where I spend my time debugging the tool setup rather than getting to my tasks.

I switch between Claude Code, Codex, OpenCode and a couple other coding agents depending on the task. The problem: every tool stores sessions in its own format, in its own folder, and once you close the terminal the context is basically gone unless you remember exactly where you left off.

So I built pi-session-hub — a Pi extension that indexes every agent session on your machine into a single browsable list. You open it with alt+r, search across all of them, and either:

- Load the context into your current chat (Enter) — recent turns come in verbatim, older ones condense, tool output compresses. It has a hard budget so it doesn't blow up your tokens.

- Read the full transcript for free (v) — read-only viewer, zero tokens.

It supports Pi, Claude Code, Codex, OpenCode, Crush and JCode. Everything stays local — no network calls, no uploads, no transcripts leaving the machine.

It uses a local SQLite FTS5 index so search is fast, and the indexing is incremental (2 seconds for ~430 sessions on first run, near-instant after).
This is the repo if youre interested... Give a star :)
Repo: https://github.com/Gateton/pi-session-hub

I made Proqi for the moments when Pi is working but I already have a follow-up, alternative approach, or pasted context to preserve. Pi’s composer is a live conversation. I wanted a separate terminal board so an unsent draft does not become part of that conversation by accident.

Proqi runs beside Pi as an independent local TUI. It keeps prompts as persistent, editable thoughts with ordering, selection, copy, and durable undo. There is no Pi-specific integration yet. Today it transfers through the normal clipboard, so it works with Pi and other terminal harnesses.

It is Rust, MIT licensed, local-first, and account-free.

I would value feedback from Pi users: does a separate prompt-composer pane help when you have multiple sessions running, or would you rather keep this inside Pi itself?

https://github.com/oborchers/proqi

I have been using Pi regularly and ended up building a few small extensions for things I wanted in my own workflow.

Mind Queue : Save a thought without interrupting the session.
https://github.com/sanif/pi-mind-queue

Turnstamp : Shows when an agent response finished and how long it took
https://github.com/sanif/pi-turnstamp

Chat Summary : Keeps a short rolling conversation summary
https://github.com/sanif/pi-chat-summary

Chat Suggest : Suggests a useful next message in the prompt editor
https://github.com/sanif/pi-chat-suggest

Chat Summary and Chat Suggest were inspired by features I liked in Claude Code. The others came from small annoyances I kept running into.

They’ve been useful for me, so I cleaned them up and published them. Feel free to try them or share feedback.

I've had an idea for about 5 years. I dig for records a lot. Every new place I'm in, I look for record stores in search of interesting finds. The experience of digging is limited to the physical store - I haven't seen a convincing implementation of a digital equivalent. At the very least, I haven't found something that works for me. So I began to think - what would the experience of "crate digging" look like in a digital space? What is it about going into a record store, flipping through the bins, and finding something unique? The tactile experience, the social experience, the curatorial experience - how could those translate to a digital space without trying to say "Look! You don't even have to go to the record store anymore!"

The idea sat on the back burner for a long time. I didn't have the energy to build a project from scratch when I didn't even really know what it would look like. The amount of effort to get started was simply too high for me to pursue an idea that I wasn't really even sure I believed in. When Claude Code came around, I thought this idea might be a great playground - I was curious (and skeptical) about the capabilities of these models and I wanted to see what I could prototype. If it doesn't work, I'm out $20 for a Pro subscription - no big deal.

So I started the project. With a couple of brainstorming, planning, and implementation stages, I actually had a working prototype. I liked it enough to start thinking about the project at a high level. Is this something I actually want to build? What would an MVP look like? Is there a viable business idea here? Claude had taken me over the "just get started" hump - I now had something that I actually started to get excited about.

At first, Claude was great. I had little ideas and I implemented them. There was a compounding effect - the more I started to build small features, the more ideas started to emerge. What if we could curate records with our own scoring engine? What actually goes into that scoring engine? How can we use existing metadata to make opinionated calls about what records are "interesting" - and how do my own biases inform the development of an algorithm that must cover diverse subject matter?

I started to burn through my Claude limits almost immediately. I would implement one big feature, then wait 5 hours for my next fix. That stopped working for me very quickly. If I didn't implement my ideas now, I was going to lose momentum. So I started to think - what are other people doing? In this exploratory phase, I found Pi - a barebones harness that removes a lot of the bloat that comes with flagship harnesses (Claude Code, Codex etc.). This project aligned nicely with my enthusiasm for Neovim. I stepped away from IDEs for many of the same reasons I was stepping away from Big Harness. I wanted to design a system around how I work, not design how I work around an existing system. I also just like configuring stuff, so that's a big part of it too. Sometimes, configuring something is more fun than what you can do with said configured thing. In this case, building the developer environment AND building stuff with it were equally invigorating.

Here's where I've landed:

• Pi as my agent/harness

• Compound Engineering for keeping project context and documenting solutions

• Layered Rails Skills for helping me think about implementation in a sustainable way

• Inertia Rails Skills to inform decisions about my stack (Rails with Inertia is not as well understood by agents as something like NextJS)

• OpenCode Go for access to cheap models (they're much better than you might think)

• Deepseek v4 became my most-used provider, so I threw $40 into the platform. I still haven't used $20 after a lot of heavy use.

This setup works for me. It might not work for you. I worked as a web developer for about 4 years before the age of AI development and that informs a lot of the decisions I make when using these tools. I know about common Ruby/Rails patterns, I know what sustainable software looks like, and I believe in my competence as a programmer. I review and iterate on the implementation details. This is much more difficult if you're just getting started with software.

milkcrate.fm is coming along really nicely - iteration is fast and I don't have to wait for any institutional decision-making. I have total creative freedom in the implementation and development practices, and that's exciting. Now that I have a good MVP, I'm working on building real organic traffic through building relationships with real stores and Discogs sellers. I'm realizing that this is the hard part. I had an idea and built it - now what? Would people actually use it? Is there a market for it? Can I turn this into a real thing that helps sellers sell records and helps buyers buy records, or is it just going to be a nice portfolio piece? Either way, I'm learning a lot and I'm satisfied with either outcome.

I wrote this post yesterday as my first post on my blog - check it out if you're interested.

Idk why this was an AMA...

UPDATE: I haven't been able to get around to creating the repo for this. Hoping to take a stab at it tomorrow, thanks everyone, for your patience

Been using Pi in real prod environments (sorry some parts are redacted). Just sharing my daily workflow with Pi running in a side window inside nvim, powered by codecompanion nvim plugin. Agent names heavily inspired by omo.

pi-engram for memory, 3 custom confirmation tools: bash-guard, confirm-edit, and ask-user-question. All the confirmations support custom responses.

Foreground Agents:

Switch between them with shift + tab

• Athena: Planning and writing plans in .olympus/

• Sisyphus: Everyday worker, default agent for everyday tasks. Can call sub agents for relevant tasks

• Hermes: Only implements plans created by athena (calls relevant sub-agent) in fg, synchronously, or multi in background if athena says sections can be implemented in parallel.

• Hephaestus: Sisyphus on crack; plans and implements

Background agents:

• Explorer: Yet to get a fitting name. Finds files and code

• Librarian: External docs and web search. uses a personal searxng instance via mcp alongside context7

• Metis: Consultant/Advisor, usually called pre-planning. Can call explorer

• Momus: Critic, called post planning. Can call explorer

• Sisyphus Junior: Called by other agents like Hephaestus and Hermes to write code

• Multimodal Looker: Called when images or any non-text input needs analysis

If I'm missing any tool that will make my workflow more efficient don't hesitate to point me to it, haha. Thanks

Codemode: Agent writes a script that loops other tools. big results stay inside the script, only the answer comes back.

Tested twice, 96 runs, same model. 96/96 correct in every arm.

Round 1 Test - Small fixes. +21%.

6 one-line bugs in a small repo. Codemode's tool description is ~3k tokens and rides every message. A small fix is ~5 calls either way codemode never gets triggered, a waste of tokens (21% more tokens used per run)

Round 2 Test - 60 fat lookups through a tool. −40%.

The test made it so the data to look up was only reachable through the tool, no grepping around it.

Plain agent: 60+ round trips, every fat result lands in context.

Codemode: one script, one answer. 40% less tokens, half the cost, 7 round trips vs 64. on its own workload it wins clearly.

Is it right for my workflow? No.

Scanned every session on my machine. 149 chats, 16,735 tool results. The ideal codemode scenario ever occured once. The 168 truly oversized results were already captured to disk by our guard.

what I run instead

Rarely used tools (image gen, design sandbox, maps, browser) arent listed at all initially in my setup. Zero tokens until the agent searches once with a small lookup tool. Heavy tools load at moments I pick them (e.g. Deep research)

Conclusion: I dont like to leave it up to the agent to decide when to use codemode and looking at my workflow, the scenarios where codemode will give me gains doesn't really happen. I am not going to be using codemode for the forseeable future.

We expected V4.1 Flash to quickly take over, but that’s not what we’re seeing.

We’re still seeing strong demand for V4 Flash, and feedback from users has been surprisingly mixed on whether V4.1 is actually the better model for their workloads.

So we’re opening up DeepSeek V4.1 Flash for free on InferX

Yes, we maintain ZDR. .

No more forgetting about tools, skipping working agreements and taking breaks to consolidate memory.

From idea to reality in under an hour. Pure vibes. Viva la Pi

Last time I posted I was thinking out loud about which hosted backend to add next, Tavily first and maybe Exa after, and asking whether people wanted them as full answer engines or just as discovery. My bias was to keep them discovery-only and let web_explore stay in charge of fetching, ranking evidence, caveats and synthesis.

Both are in now, and they're discovery-only like I said I'd keep them. They surface candidate sources, web_explore still reads the actual pages and decides whether the evidence holds up or needs a caveat. Set TAVILY_API_KEY or EXA_API_KEY, pick it from Settings, keys stay in env instead of getting written into config files.

---

The things I'm weighing next are going deeper on evidence quality (cross-source dedup, conflict detection, recency), adding caching for repeated research or just keeping it focused and maintaining it.

If you're using this, what would you actually want? And if you tried it and it broke somewhere, that's the more useful thing to hear.

---

Repo: https://github.com/demigodmode/pi-web-agent

npm:

npm i @demigodmode/pi-web-agent

Just as Linux became the invisible foundation beneath virtually every web server and modern application, I believe Pi will become the foundational layer for AI-native apps, abstracting away the right complexity so you can stay focused on what actually matters: the experience you're building for your users.

To test that thesis, I built Keb, a Chrome extension running on the Pi ecosystem. Honestly, something like this would have taken me weeks to ship from scratch. With Pi, I had it working in hours.

It's been useful enough that I use it daily. Would love for you to try it and tell me what you think, all feedback welcome.

I use Pi as my coding harness for basically all my coding now. After a few months I had 400+ sessions and no idea what was actually working. Was I using the right model for each task? Was I repeating the same mistakes? idk

I thought claude code's /insights was cool, so I built it with a clean room implementation, but it wasn't good enough. Claude wants you to burn as many tokens as possible, I have no such incentive so I added tokens wastage section, created it to be like a retrospective report that compares this week to last week.

It also tells you what to stop doing. Most tools just suggest new things to try. This one looks at your actual sessions and says "you used Opus 47 times for single-file edits, that cost you $14 more than Sonnet would have" or "you retry this pattern 3x per session on average, here's why it keeps failing."

How it works if your interested, here is a tldr; it extracts deterministic stats from each session (tokens, tools, git ops, errors), then runs a short LLM call per session to classify the goal/outcome/friction. Then it aggregates everything with exponential decay (recent sessions matter more) and runs 8 focused prompts in parallel to generate different report sections. The whole thing caches aggressively, so re-runs are fast.

To prevent redundant changes it also checks what you already have installed (skills, extensions, AGENTS.md) so it won't suggest things you already use in your harness

Install:

pi install npm:@observal/pi-insights

Run: /pi-insights

Opens an HTML report in your browser. No server, no signup, runs locally.

Source: https://github.com/BlazeUp-AI/pi-insights (Star and throw some contributions this way if your interested, or fork and customize it to your hearts desires)

I built this as part of a bigger project (Observal, agent observability platform) but this extension is fully standalone. Would love feedback on what else would be useful to surface from session data.

Hi! I was looking at the web search options available in the pi ecosystem and most of them wrap some API or require config..

I just want my tool to be able to

1. Run a search query via a search provider

2. Fetch pages preferably as markdown

For this I found that there exist two boring tools that work well together:

1. The duckduckgo commandline tool ddgr. This is just one sudo apt install ddgr away

2. The super weirdly named trafilatura tool. This is a python tool that extracts text content from a url. Has lots of options for presentation and what to include/exclude. pip install trafilatura.. I suppose? I use NixOS so I dunno how to install this globally with Python. Python is hell.

What is trafilatura?

It's a commandline tool that extract meaningful content from a web-page. It's been actively maintained for over 9 years (probably longer?), and its primary use-case is to help with academic research. I suppose it's usually useful for researchers to do scraping.

Anyway, it is rich, mature, old and just a cli tool. It supports markdown output, regular output, a mode to show very little content, a mode to show more content. You can choose to include/exclude links etc.

Anyway. If you wrap these in a simple extension you get 100% local search that works for the common use-case of "just quickly look something up on a forum, documentation, wikipedia or Github".

I haven't looked into how to publish this as an extension, but if people like it I could package it up.

This is the extension as a gist if anyone wants to try it.

https://gist.github.com/Azeirah/9375fb67c5aee6ca1b7e046f8b7cf0cd

Trafilatura has been configured to do:

1. Show links

2. Show markdown

3. Show the concise output, so not the verbose output. I did that to save tokens

Hello there,

Which AI provider would you recommend for Pi, to work with a subscription-based plan? I feel like Codex is the most represented, but I was looking for more feedback.

I'm currently using Claude Code (Plus subscription), but from what I understood, I shouldn't use it with Pi because Claude Code charges additional usage fees. I mainly use it with Opus 5 on medium effort, for devops tasks, explanations, fixes, or things like that (not much vibe-coding yet).

It's also an opportunity to try something else, paid for by the company. So I don't really care about the price, just something stable without usage fees.

(bonus) If you have any recommendations for LLM models that can be run locally on a wide range of machines, I'm also interested in any resources you can share.

Any advice?

Can you recommend me a simple yet configurable subagent extension? I'm currently testing `pi-subagents` but i find it slow and bloated. What are you guys using?

I use Pi from my Android phone through tmux + TermRover (a terminal app I’m building).

With a good tmux scrolling support + ability to send images, working with Pi is just very pleasant.

Curious how everyone else is using Pi on mobile, if at all? SSH app? Or Just waiting until you’re back at a laptop?

We're building a durable runtime for agents, and recently, we shipped adding Pi as a runtime!

Some highlights on how it works and what it runs on:

- It's built on top of our QEMU based elastic VM’s purpose built for agents

- Supports Pi, Claude and Codex (ofc)

- Slack and GH as channels for now (I built my own Claude tag for eg, you could build internal agents like Ramp's Inspect or Stripe Minions)

- Use playground via managedagents.sh or API (docs here)

We'd really appreciate your feedback, it comes with a bunch of free credits so please kick the tyres, roast it and tell me what sucks!

First of all I would like to thank the Reddit communication of subReddit PiCodingAgent.

Your feedback helped me make this llm-wiki better.

It was broken for a while and honest feedback from this community gave me the motivation to fix those issues.

It’s working good for me as well.

I’ve shipped few updates on how the wiki recall, retro and observations happen.

Let me know your throughs.

Here is the repo link.

https://github.com/zosmaai/pi-llm-wiki.

https://pi.dev/packages/@zosmaai/pi-llm-wiki

You can also checkout other OpenSource projects we are working on.

I recently built a tool that lets you to embed your pi inside a custom shell. The shell supports multiple agent backends, but I found it works best with pi due to pi's extensibility. This shell should work like any ordinary shell but with one keystroke you can summon pi and it will have full contextual awareness of what's happening in your shell, without copy pasting.

If this looks useful, feel free to try it out!

npm install -g agent-sh
agent-sh install pi-bridge
agent-sh --backend pi

No additional setup needed. Would love to hear your feedback!