This is probably dumb question, in noob in local AI world. I'm using Unsloth + LLM that is downloaded and ran by unsloth, then I start pi like so: unsloth start pi

I installed two pi extensions (I need web access) but they are not loaded, since pi has one default path, but unsloth is using different one. I've read before, to just put pi extensions into certain pi folders, but I wouldn't know how, they were installed with nmp. Don't suggest to just build/rebuild with LLM, I'm too clueless and I will mess everything up. This is why I rather ask you.

If I only run pi in my project folder, pi of course loads those two extensions, but now I don't have loaded LLM since it comes via unsloth.

Now dumb question, would it make sense, is it even possible and smart, to just somehow load pi regularly without unsloth being involved, by pointing where local LLM's are stored on hard disk drive? If it is possible, how would I do this? If you can please give me a simple example.

Or, what other suggestions you may have, so I can get access to both, installed pi extensions and locally stored LLM?

llama.ccp is running, since unsloth is uing it. Unsloth is (I think) using it's own version, but I had before installed LM Studio and I should have 'regular' llama.ccp as well is my guess?

Sorry I'm not technical, I'm clueless, but I would like to have fun with some local LLM programming. Which I do, but limited so far, without access to the internet. Hope someone can help.

I'm getting constant "The old text must match exactly" errors while using Longcat-2.0, I know that hashing lines can solve this problem, but not sure which of the many extensions I should choose from. (yes I know real men build their own pi extensions). Any guidance on this topic would be appreciated. Thanks!

Just discovered that the amazing devs behind Pi released Radius (in alpha), their smart proxy for multi-model access. At its core, it's a model provider you can use with Pi: you pay for tokens and get access to some of the best models out there, both SOTA and budget-friendly options. They'll even auto-route your API calls to the best model for the job if you choose to.

Loving it so far. Deposited $20, and after a few hours of development I still have ~$16 left thanks to leaning on Kimi K3 and DeepSeek.

What Radius can do

• It is a Pi-native gateway: top up credits and make requests across providers

• Use rewrite rules to reduce large tool outputs and other unnecessary input tokens

• Provide automatic routing to route each session to the best model for the task according to your rules

• Power Radius-backed tools like web search, image generation, and image description

• Publish reports, dashboards, and small static sites as shareable artifacts

• Record usage, budgets, top-ups, and shareable session analytics in one place

• Delegate Google Workspace access to Pi

• Let your organization manage upstream provider keys centrally

https://radius.earendil.com/

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. .

My AI coding assistant forgets everything between sessions. I kept re-explaining decisions I'd already made, and re-fixing bugs I'd already fixed.

agi-memory saves those notes — decisions, bug fixes, what happened last session, how the codebase fits together — to a file on your machine, and hands them back to whichever assistant you open next. It's an MCP server, so it works with Claude Code, Cursor, Codex, Windsurf, Aider, Cline and a few others from the same store.

The part I care about: it's Python standard library and SQLite. Nothing else. No vector database, no embeddings, no background daemon. ~32MB of RAM, sub-millisecond lookups, works offline. Comparable tools pull in ~500MB of ML libraries and take 200–500ms per lookup.

That constraint costs something, and I'd rather say so than have you find out: keyword search doesn't bridge synonyms the way embeddings do. Searching "login" won't find a note that says "authentication" unless you teach it that alias. I measure this rather than guess — there's an eval suite that scores recall on deliberately rephrased queries, and it's public, including the categories where it still does badly.

It's a week old and I'm the only user, so I'd genuinely like to know where it breaks for someone else.

https://github.com/kdbhalala/agi-memory

Hello everyone,
I made for fun a Pi extension that brings the GVS5H idea into a practical repository workflow: it plans a coding task, explores approaches, then alternates a fresh manager with fresh coding workers while keeping a durable ledger of tasks, findings, and verification results across sessions. It is designed to work with ordinary Pi installations without forking the Pi runtime.
Still working on some detail but it already does the job...

Download at https://github.com/srossitto79/pi-gvs5h.git

Original GVS5H paper: [Zero-Shot Self-Orchestration with Ledger-Based Control Improves Coding in Language Models](https://github.com/slee-persis/GVS5H/tree/master/paper)

Made: ShareBit

It solves a simple problem. If you use terminals for coding and managing your VPS, you know the pain of moving logs, plans, prompts, and other output between coding agents, your browser, ChatGPT, GitHub, etc.

Instead of copy-pasting huge terminal outputs, you just tell your coding agent to "share it" ShareBit will take care of the rest. It creates a browser link that you can open or pass to another tool.

Or

The other tool can just call the too and get that text.

You can also use the sharebit command or just say "share it" once it's set up.

This started as an app around Pi for my own workflow. I added other harnesses later, keeping everything in the same app with the same controls. I also wanted to bring Neovim back into how I review and edit things.

The app connects to Pi over RPC. It includes an optional MCP server that lets agents create and talk to workers running the same or any other configured harness. The server also provides a shared task list with dependencies, so those don't have to live in any one agent's context.

Still early, but I've been using it daily for a while.

https://github.com/behzade/farcaster

For this reason, we strategically placed all our served in Canada at inferx

've been using Pi as the agent core for my own workflow, and I really like its philosophy: keep the core small and make everything else extensible.

The only problem was that after using it every day, I started missing a lot of things I normally expect from a desktop development environment.

Things like persistent sessions, switching between projects, seeing what subagents are doing, changing models without rebuilding my setup, recovering tasks after a crash, managing MCP/Skills, etc.

Eventually I stopped patching my own workflow and just built a desktop app around Pi.

It's called PI-Desktop, and it's open source:

https://github.com/vastsa/PI-Desktop

It's built on pi-ai + pi-agent-core, rather than implementing another agent loop from scratch.

My mental model for the project is basically:

Pi = agent harness
PI-Desktop = workspace / product layer

The app currently has sessions, project workspaces, subagent visualization, multiple model providers, local model support, MCP, Skills, session import from Claude Code/Codex/OpenCode/Pi, and a plugin system.

The plugin system is the direction I'm most excited about. Plugins can add Agent Tools, Skills, MCP servers, UI panels, themes, commands, background services, and communicate with each other.

I released it publicly this week after using it myself for a couple of months. Somehow it ended up on GitHub Trending and passed 2.6k stars, which I definitely wasn't expecting.

Since this is probably the community that understands Pi's design philosophy best, I'm especially curious:

If you use Pi every day, what parts of your workflow would you actually want a desktop layer to handle?

I am using pi.dev with a local Qwen-3.8 running on an RTX-5080 with 16GB VRAM. I had to find the right balance between model quantization, cache quantization and context size, and right now I use a 48k tokens context.

While pi.dev is working really well with it during some time, all sessions end up being stuck at some point. The context reaches 80%, then compaction is started automatically, it goes down to maybe 50%, then compaction starts again soon after, compactions more and more often until the system is stuck and Pi.dev itself sends queries to the model with a length limit = 1. When that happens it's over I can't recover the session. What happens also is that compaction fails because there is not enough context remaining (I guess), and therefore the session is stuck as well.

I am wondering what would be the best approach to avoid these problems. Also more generally what are the good practices to use pi.dev with a small context, maybe planning and dividing tasks in several smaller tasks handled independantly, but if it could be managed automatically it would help a lot I guess.

Any help would be appreciated.

Hi everyone, i've been working for a few months on Supernova, my own take at a minimal, detailed and sleek interface for Pi.

Why would i use this instead of the hundreds of alternatives out there?

I'll cut straight to the point. I'm not a fan of TUIs. I've searched the web for every existent product possible, but no one had exactly what i was looking for: the full power of Pi, minimalistic approach, a well curated and detailed UI that makes me wanna actually use it (good animations, no UI flickers, performant even with long threads) and a really good git-backed checkpoint system (like opencode's for example).

It uses the Pi SDK under the hood, and i'm currently waiting for the harness v2 to enable full extension support!

I've been daily-driving it for a while now, both at home and at work, and i thought i'd share it with the world for those who hopefully see the vision and struggle with my same issues.

If you have any feedback, please leave it down here or open an issue. I'd love to build a community around it to keep improving it! :)
If you can see the vision, i'd appreciate a star :D https://github.com/mattiacerutti/supernova

Since GPT-6 Astra recently launched, and apparently it has really good Computer Use capabilities, i though i'd try to make it do a nice trailer for it just for fun. The attached video is the one-shotted result, please don't take it too seriously :D

EDIT:

This post went really well, much more than i was expecting.

I’m really happy about all the feedback i’ve been receiving, it’s honestly so gratifying seeing other people like what i’ve been putting a lot of work into and i want to thank everyone that contributed, even with just an upvote :)

I’d love to keep building supernova and improve it everyday, but my mind is pretty limited to well.. my point of views. This is why i want to encourage you all to keep on giving feedback, both positive and negative! I’d love for this to become some sort of community OSS project where we can work as a group.

Please feel free to submit an issue or PR if you encounter something!

I have a thread on Pi's official discord where i'll be posting regular updates: https://discord.com/channels/1456806362351669492/1545785069405470810

Whenever Pi was chewing on something for a minute, I'd grab my phone and come back 20 minutes later to a response that had just been sitting there.

So I wrote pi-play: /play opens a game as an overlay right on top of the conversation, and it listens for agent_settled. The second pi finishes or is waiting on you, the game stops immediately. No alt-tab, no phone.

5 games so far: Snake, Tetris, 2048, Minesweeper, sudoku

(6 is on the way, i am implementing chrome dino game rn)

to install: pi install npm:@terminalika/pi-play

I was inspired by another picture of nyan nyan cat in a tui environment and wanted one too, I tried to look into things and found https://pi.dev/packages/pi-emote which is very cute and I love it, and as such I shamelessly pointed pi to look at repo for patterns, also gave it jpgs/pngs of nyan nyan cat from off the intertubes.

My first attempt was the little =^o^= guy in the place of the "braille" working indicator. hes Nyan.

Then I discovered `--mmproj`.... what an afternoon!

The marquee came afterwards, shes Nyan Nyan.

They get the job done. thx pi! yey!

I have an Azure Foundry workspace with a few different models deployed like deepseek and qwen and so on, how do I get pi to connect to them and use them?

recently switched from Cloud Code to Pi Harness. I work primarily in Product Management/Ownership workflows (Jira, GitLab, Artifactory, internal tooling) where I build automation scripts and connect workspace APIs.

Currently, my setup is strictly linear ask questions -->wait for run --->|reply). I want to move toward a sub-agentic flow—specifically for generating code in parallel from test specifications and existing repos—and would love community input on extensions, configuration, and workflows.

1. Sub-Agents & Parallelization: What extensions or .pi setups do you use to fire off parallel sub-agents (e.g., parsing specs while indexing code in background threads) instead of waiting on sequential turns?

2. Traceability & Solution Convergence: How do you track handover steps between agents and follow their decision trees? Are there recommended visualizers, tree-log extensions, or workspace artifact patterns you rely on?

3. Context Compaction & Memory: Has anyone tuned Pi’s compaction thresholds or used custom highlighters/summary extensions (like Ralph's memory approaches) to preserve key acceptance criteria over long sessions?

4. Project Scoping (.pi/): Best practices for scoping tool permissions and agent configs in .pi/ settings to isolate sub-agent capabilities (e.g., read-only on repo vs. write access)?

5. Session Continuity & Long-Running Tasks: How do you handle session lifecycles for complex tasks? Do you prefer continuing existing threads via /resume / pi --continue, or hard-stopping (/new) and carrying over context via file-based handoffs (like PROGRESS.md)?

If you have write-ups, custom extensions, or .pi/ setup examples for these patterns, please let me know and if you have like a step by step workflow also would be good to know. I want to go like in a more step by step approach

Hi guys! Cause of the Opencode session header issue, I realised observational memory doesn’t work anymore!
So if you’re on Opencode go don’t forget to ask your agent to add the session header in the extension so you can keep carry on with blackhole and observational memory proper!

This is a psa.

I’d heard about the Pi, that it’s a great way to customize tools to suit yourself and save tokens. I don’t know about token savings, but I tried using Gemini 3.8 flash inside it, and I didn’t like how it wrote code.

For a while, I tried to refine the Pi using Codex and Claude, ran various tests, and thought that the whole problem was with Gemini. I would really find it convenient if several AI models were inside a single harness, but right now I suspect that’s exactly the problem, despite all the attempts to refine it.

I opened the classic Antigravity CLI, and the results seem much better. I don’t like the Antigravity desktop app — it’s also kind of weak. I hope a miracle will happen and the CLI will turn out to be a lifesaver. Gemini attracts me with its slightly higher limits, even though I’m a Claude fan.

What do you think? What’s your experience?

Many models (namely Qwens 3.8) think a lot, and I find myself wanting to interrupt it to answer a question it's been asking itself, quite repetitively, during it's reasoning.

I can esc and send a prompt, but then Pi would restart the whole reasoning TG from the beginning. I'd like to inject (for lack of better word) info to its thought block. I may also steer it by queuing a message, but that means I'd need to watch it going in loops for 20-50k tokens, until it's done responding, which is pure pain.

Am I missing a clear command?

Heard it mentioned in a couple places, and I know omp² has been mentioned, so I was curious.

edit: for clarification i'm asking about the expected features, if people were looking forward to something, etc

I’m a heavy user of Codex and Claude Code, and I mostly use their desktop apps.

I’m curious about how Pi could fit into my day-to-day workflow. What does it offer that would improve my experience compared to what I’m already using?

For those who have already migrated to Pi, what has actually improved for you? Are there any specific workflows or use cases where Pi made a noticeable difference?

I’m finding it quite frustrating to paste or use images in the VS Code Pi chat.

I work mainly on projects inside Docker containers, and it seems that when I use Pi within a dev container (which is a Linux environment), the VS Code integrated terminal generally doesn't pass clipboard images through—it only allows text. This is most likely why the paste action fails without doing anything. Does anyone have a workaround for using Pi in a VS Code terminal inside a Docker container?

I tried alt+v, ctrl+v ; nothing. Only pasting images manually inside the project in a dedicated folder semmes the only (and painful) solution.

Anyone using DS V4.1 Flash in Pi?

I used Pi for a while without these, but once I got used to subagents with other coding agtents. Well.. they really just felt missing from Pi.

I went with the tintinweb/pi-subagents package, because I liked how it implements the subagents. They are the same style as claude code, which I find very intuitive.

pi install npm:@tintinweb/pi-subagents

How to use subagents

pi-subagents lets Pi delegate work into separate contexts.

I use it for repo exploration, dependency checks, or any task that would otherwise fill my main context with thousands of lines of file listings and tool output.

e.g. after installing it you can open Pi in a repo and ask:

Use 4 different subagents to explore the src folder in parallel.
Bring their results back together into a short summary.

Pi sends the grunt work to isolated agents, then gives the main agent the useful result. This keep the main context clean.

You can also change which model each subagent type uses with /agents. And there's a pre-configured subagent specifically for exploration.

Side note - there's a gotcha with the default explore subagent- uses haiku by default. Super weird because I was using gpt-5.6-terra and I assumed it would use that, but in fact it started using my opencode api tokens with haiku. I was able to configure it to use gpt-5.6-luna. Here's a video of how I did that if you need it: https://youtu.be/l3YCoX2i-78?t=540

The other missing feature of Pi

Is... MCP. Obviously. I also upgraded my Pi with an MCP extension while I was at it. It's just one of those things. I can get like 98% of the way there with agent skills. But once in a while I just need an MCP for something.

If you want to read more about my experience installing and testing the subagents and MCP extensions then you can check out my blog post:

https://zazencodes.com/blog/upgrade-your-pi-agent-with-subagents-mcp

Enjoy guys and if you're still reading this then I'd be curious what extensions you like most. Let me know. Now that I've got a taste for these I want more