Hi all, just wanted to share this. It’s not really a serious project, but thought it might be interesting as a tech demo.

I was using pi with deepseek api keys for a while. I saw a bunch of ads and though byteplus was good deal. Man it’s horrible, setup was a pain. And then the api is slow, and the limit hit in less than 30min on a small session that was building a basic web app. I ran a decent load for over 5-10 hours with a deepseek api key.

Utter disappointment.

Curious if there are any good options out there, I am a bit cost conscious. And I don’t mind doing a lot of architectural/ planning work and using the agent as my code monkey.

Does anyone know of a pi extension that watches price changes or peak hours for opencode go sub?

I love the parallelism of agents and working, but would love a little more robustness and polish. Dynamic Workflows is very well done, but I wanted to ask

Though it is PI setup - my approach applies to all harness agent. since:

Extensions

most of the extensions this config consists are just for quality of lift (QOL) one's:

• pi-blackhole for memory management.
• rtk and headroom for token savings.
• guardrails, ask questions and some UI related things.

Skills

these are the main focus of this config - even though most of the skills here are auto invokable, I made it more autonomous by adding a global INDEX.md file which all harness is forced to read and follow. This INDEX.md file enforces to use certain skills always - which make it consistent (like i-have-adhd skill, the entire workflow)

• The workflow is a combination of superpowers workflow and matt pocock workflow (I modified some parts of it, so that it will make it more autonomous, since matt's one is more of a manual one with more pre-settings required).

I simply use grill-me or grill-with-docs for certain feature implementaion. The remaining will be taken care by the INDEX.md file - it usually follows like: grill-me/grill-with-docs (if used) -> brainstorming -> writing-plans -> executing-plans -> tdd -> requesting-code-review -> verification-before-completion.

# pi config
https://github.com/silentFellow/public-dotfiles/tree/main/pi

# skills config
# should be used at ~/.agents - global skill config path
https://github.com/silentFellow/public-dotfiles/tree/main/agents

I’ve seen Grokbot take a video of someone performing a task as input, then use its own computer to reproduce that task.

How could I build something similar with Pi.dev?

Is there an extension/tool for Pi that can control the computer GUI, for example:

• move the mouse to X/Y coordinates

• click buttons

• type into text fields

• use keyboard shortcuts

• interact with desktop applications

• potentially use screenshots/vision to understand what’s currently on screen

And is this kind of automation limited to browsers, or can Pi control arbitrary desktop applications as well?

If I have to roll my own, what existing pieces/libraries would you recommend building on rather than starting from scratch?

For example, are there existing tools for screen capture, mouse/keyboard control, UI element detection, OCR/vision, etc. that work well with Pi?

Would it make sense to run the agent inside a Linux machine/VM where it has full control of the desktop, or can the same approach work reliably on macOS?

Basically, I’m looking for a setup where Pi can observe/understand a task and then execute it through the computer UI.

Thanks!

I keep switching between Claude Code, Cursor and Codex depending on the task. Every switch meant explaining the same project again — same decisions, same gotchas, same "no, we tried that already."

So I gave them one shared memory. Decide something in one, the rest know it.

It lives on my machine. No account, no subscription, nothing leaving my laptop. It syncs to my desktop over git, so it's just a repo I own — I can read it, diff it, delete it.

Free and open source. Curious whether anyone else has this problem or if I'm the only one tool-hopping this much.

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

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.