trying to move off from Claude Code to Pi. Im pretty happy with features and outputs, but I really dont want to be in the terminal. With Claude Code, I use it with the VS code extension or webUI almost exclusively. Are there any nice looking front ends for Pi?
The few VS code extensions I've found seem to just wrap the TUI
I've been building pi-hive, a Pi extension that runs a whole hierarchy of agents on a project instead of one session, and I've reached the point where I want to know two things before I sink more time in:
Would anyone actually use this or does something like it already exist? I haven't found a Pi-native equivalent, but I'd genuinely rather hear "X already does this" than reinvent it. If you know of one, please tell me.
Anyone want to collaborate? It's MIT, early, and rough. I'd love co-maintainers or even just people willing to try it on a real project and tell me where it breaks.
Here's what it does today:
It's on npm, so it's a one-liner to try:
pi install npm:pi-hive
Fair warning: it's unpolished and there's plenty of rough edges — I'm sharing it now to gauge whether it's worth pushing further, not because it's finished.
Repo (MIT): https://github.com/demetere/pi-hive
If you'd use something like this, or you're building something similar, or you want to help — I'd love to hear from you.
my team just keeps pushing a messy claude.md file, i got very irritated when suddenly it does random plans. decided to switch to pi just so i can ignore these files.
so i just customized pi and made sure it does not load from the project but i have my own off project agents.md file .
i load from
~/.pi/agents/projects/<projectdir>/AGENTS.md
really like pi after i did this, suddenly, i can see the power of customization. i have since created a planner and subagents (not custom code but simple prompt based alias using -p and -tools) . so far love the experience.
any of you have any tips , power users out there ? would love to try to learn how best to get the most out of pi.
I know being terminal-bound is a badge of honour, but I’m surprised not to see more easy to use, accessible, user interfaces.
I built pi-scheduler, a small extension for Pi that gives coding agents a clock.
It lets the agent schedule future actions like:
An use case example: an agent creates a GitLab/GitHub pipeline, sees it's still running, and schedules itself to check again later. When it wakes up, it can inspect the result, debug failures, or schedule another check if it's still pending.
Example:
Check this pipeline again in 3 minutes. If it passed, report success.
If it failed, inspect logs and fix it. If it is still running, schedule
another check.
Install:
pi install npm:@jl1990/pi-scheduler
Links:
It currently uses in-process timers, so it's best for live Pi sessions. If Pi is closed, missed tasks run when the session loads again. Future work could add cron / systemd / daemon-backed scheduling.
I’ve been working on Curion, a memory system for AI agents built around a simple idea:
The main agent should not have to manage memory manually.
Most AI agents are useful inside a single session, but they still lose important context between sessions. Project decisions, implementation history, constraints, unresolved tasks, and previous reasoning often disappear unless I manually write long handoff notes.
At first, the obvious solution seems to be giving the agent memory tools: save, search, update, delete, edit.
But that creates a second problem.
If the main agent has to manage memory by itself, it can easily receive too many raw memories. Some are relevant, some are stale, some are only partially related, and some may conflict with newer information. The agent then has to spend context and attention deciding what matters.
That creates context bloat.
Curion takes a different approach.
I think of Curion as a librarian for AI agents.
A good librarian does not just throw every possibly related book at you. They understand the question, know how information is organized, filter what matters, notice conflicts, ask clarifying questions when needed, and return the most useful context.
That is what Curion is meant to do for agent memory.
The main agent only needs to say:
“I want to remember this.”
or
“I need to recall something about this.”
Curion handles the rest.
When saving memory, Curion can decide how information should be stored, whether it relates to existing records, whether something should be updated, and whether a conflict requires clarification.
When recalling memory, Curion does not just dump raw search results into the agent’s context. It retrieves relevant records, evaluates what is useful for the current task, synthesizes the context, and clearly says when nothing relevant was found.
The analogy I use is human memory. When we want to remember something, we do not consciously search through billions of memories. We ask for what we need, and the relevant memory appears automatically beneath the surface.
Curion is built around that same interface idea for AI agents.
It is project-first: Curion focuses on the project the agent is currently working in. It can also use cross-project recall when information from another project is actually relevant.
Curion is not just a save/search tool. It is a collaborative memory layer: a specialized memory librarian that helps agents remember responsibly, reduces context bloat, and gives the main agent only the context it actually needs.
GitHub: https://github.com/geanatz/curion
NPM: https://www.npmjs.com/package/@geanatz/curion
Portfolio: https://geanatz.com
I just got a notice saying gpt 5.4 is no longer available on my pro subscription im Pi . 5.5 is fine. 5.4 has been a bit of a workhorse for me.
I opened the codex app and it's disappeared there too.
I'm kinda new to Pi I've used Gemini CLI, qwen Cli, opencode and some more before but PI is the first bare bone harness I've tried any recommendations for MCP, skills and pi extensions?
Really loved the side-chat feature of the Codex app.
It was an easy way to understand issues and brainstorm solutions without polluting the main thread's context, so implemented it for Pi.
Link: https://pi.dev/packages/@snehalyelmati/pi-tmux-sidechat
Pre-requisite: tmux session with Pi.
How to use,
/scc, for side-chat connect./new) and reconnect (/scc).Note, if there are multiple panes with pi, it'll show a picker for you to choose from.
I honestly debated even making this post, and kind of wondered if I am even in the right subreddit for it. I know I have been posting a bit about my own IDE extension here, but looking through the feed lately at all the rate limit issues and context drift, it really feels like people are making things way harder than they need to be by trying to morph Pi into the wrong tool for the job.
The whole point of Pi's architecture is that it is meant to be a lightweight, minimalist agent. It just feels like when folks start bolting on massive complex layers or completely rewriting how the core operates, they are just fighting the actual design of the tool itself. Honestly, if people just read the documentation, a lot of this could be avoided. Every design reason and exactly how the architecture is supposed to work is explained in detail right there.
If you have to fundamentally gut Pi and fork its internals just to get a project running, it might be worth asking if it is even the right base layer for what you want to do. There is really no need to over-engineer it to death. Let Pi do what it does best. Just my two cents.
EDIT: Just to clarify based on some of the comments, I am not trying to tell anyone how to use Pi. If building a massive custom setup is what works for you, that is awesome. My point is just about the friction. If you find yourself constantly fighting the architecture, hitting rate limits, and reinventing the wheel just to get a basic workflow going, it might be worth asking if you are forcing the wrong tool for the job. Really appreciate the great discussion happening here.
I built a harness for myself. It runs on my own machine. Its beautiful, fast, and built for professional work (I use it for my job).
The aesthetics and design was important to me, had to be easy to use, informative, feature rich but not bloated.
Features I built into it:
Nice touches: full system terminal access, a ⌘K command palette with cross-project search, a usage dashboard that counts every token, live system status, a real note-taking app, plan mode, light/dark themes, native notifications when a turn finishes, and hourly encrypted backups.
My goal with this post is to inspire others to build their own harness for themselves, its actually tons of fun! Like building out your workshop or garage the way you want to help you create, repair, & experiment on things.
Ask questions across your Markdown notes using a fully local Graph RAG engine. Built for Obsidian vaults, works with any folder of Markdown files. Extracts entity-relation triples from wikilinks & YAML frontmatter, retrieves answers via hybrid search (vector + BM25 + temporal). Multilingual. No cloud. Runs on Ollama.
I built telepi because I wanted tighten integration for telegram and pi coding agent.
The idea is simple: messages from bot topic are routed to the corresponding session and vice-versa.
My primary use case: every agent becomes a folder on disk with own scoped extensions and skills. But this can be used for arbitrary coding sessions.
By default only messages are shown, but this is configurable, though will likely require tweaking.
The tool is designed to not interfere with existing solutions: if topic is not registered within telepi, it is ignored.
To get started, ask your agent to clone the repo and do the setup. You'll need bot token to get things going.
It is not required, but highly recommended to create the first topic right away so that you could manage other topics/sessions from telegram.
I built a spec-driven development kit for Pi and have been running my own projects on it. Posting here because this is the crowd that would actually use it, and I want the feedback on where it fights Pi's flow.
The problem it solves: Pi is capable and has zero memory between sessions. Ask it to "add authentication" and you get 500 confident lines that compile and solve a slightly different problem than the one you had. pi-sdd-kit makes you specify before it codes, as skills you invoke: /skill:sdd-prd, /skill:sdd-spec, /skill:sdd-tasks, /skill:sdd-exec, /skill:sdd-review, with a human approval gate between each.
Two parts do most of the work.
First: steering docs as durable memory. product.md, tech-stack.md (with the reason for each choice, not just the name), conventions.md, and principles.md live in .ai/steering/ and load every session, separate from per-feature specs. The reason line is what pays off: "we use Postgres because payment records need ACID" stops the agent reaching for SQLite three sessions later.
Second: .status is the only gate. One line per feature: requirements:approved, then design:approved, then tasks:approved. The agent reads it before it does anything. A finished-looking design.md on disk is not approval. Only the token is. That stops an eager agent from racing a draft straight into code.
Requirements go in EARS (WHEN / IF / WHILE / SHALL), which leaves almost nothing to interpret.
Install:
pi install npm:@felipefontoura/pi-sdd-kit
# then in Pi:
/reload
/skill:sdd-init
Repo, with the full command reference and templates: https://github.com/felipefontoura/pi-sdd-kit
Longer writeup and the crypto-fintech case study it came out of (13 apps, ~70 days, solo): https://felipefontoura.com/articles/spec-driven-development-case-study
Coming from Claude Code I wanted specific skills to use specific models, but that was not supported out of the box. This plugin allows you to set the model: in the frontmatter of any skill.
It also checks if all configured models are available at Pi startup or /reload.
Skills have no fallback. This is by design, so skills never fall back to less intelligent or more expensive models.
Install: pi install git:github.com/MitchelliJ/pi-skill-model
Github: https://github.com/MitchelliJ/pi-skill-model
Open to feedback.
One of the selling points was that its edit mode was more reliable. Actually, my model struggled a lot and would routinely end up with garbled files. Whereas in pi-coding-agent the edits pass about 80-90% of the time and when they fail the file remains untouched.
Also, it seems to inject about 25K tokens of context? Which is a lot on a small local model.
Also it would end up with 60K+ of context after compaction, which is still a lot.
I liked how sleek the UI looked though especially with a Nerd font. But it's not better.
I'm struggling to find the right model setup for the best quality-to-cost ratio. My current multi-agent setup has 5 subagents plus an orchestrator, and I feel like it's eating through my rate limits more than it should.
Here’s what I've got running:
I like the overall subagent framework, but the model assignment feels totally off. Any suggestions or improvements on how to optimize this?
An OMP user reached out asking for a tool that confined their agent to a single directory. So I spun one up. Works with any agent though. Open source if you want to try it out.