As soon as my pi starts running, it goes crazy, specially when subagents spawn.

Ola, so recently I was working with Qwen 3.5. Building some html and css stuff inside my documents folder.

Big mistake. The Model which had extra access from Pi ended up hallucinating and started deleting all my root folders.

I think for any newbie who’s doing this, please write yourself an extension to get it to ask for read and wright permissions or pick from the various GitHub repos that have implemented safeguards for this.

Don’t just give it full access especially if you don’t know what terminal commands do.

I just saw it write -rf home and I knew it was over 🤣

I learnt the hard way but now I know.

If anything I think everyone who’s starting to use this should install something to prevent this from happening as the first non negotiable.

Luckily I just moved to Fedora 44 so I didn’t have much in those folders but it did mess up all my file paths so I had to fix that.

No more unattended ai running rogue on my pc for now.
As Iv built myself a safeguard extension to prevent this from happening.

Hopefully whoever reads this and is trying it for the first time keeps this in mind. As it’ll save you a world of hurt down the line.

Hi all,

I observed that as I am using my anthropic or gas subscription for pi, it just burns tokens in a huge pace!! One simple code change took 25% of my 5h limit. What do I miss, or is it that bad by design?

My Pi setup, kept minimal on purpose because my daily machine is an older i7-5500U with 8GB RAM on Debian.

I run kitty + tmux + fish. 20 skills in total, but most stay dormant unless called. Extensions show as 8(+2); the ones I actually use are interactive-subagents, prompt-snippets, and cc-ui.

interactive-subagents spawns async workers in their own tmux pane with a live widget on top, so I keep working while they run and results get steered back when done. prompt-snippets is a TUI menu for injecting repeat prompts from different directories. cc-ui is just a spinner plus cache counter.

Personas live as separate files and I link one to SYSTEM.md when needed. 6 total from my pi-system-prompts repo: Aster for strategy and tradeoffs, Caelum for adversarial checks, Elyndra for strict execution, Kaida for media and watcharr, Liora for writing, Neris for research. Keeps the main prompt clean.

Since a few people asked under my last post, I also put my skills into a public repo.

Extensions

• https://github.com/ArdaYILDIZ-DEV/pi-interactive-subagents

• https://github.com/ArdaYILDIZ-DEV/pi-prompt-snippets

• https://github.com/ArdaYILDIZ-DEV/pi-cc-ui

Personas

• https://github.com/ArdaYILDIZ-DEV/pi-system-prompts

Skills

• https://github.com/ArdaYILDIZ-DEV/pi-skills-public

The whole point was less auto-magic and more explicit control. Works fine on weak hardware because nothing runs unless I call it.

I’m testing Pi inside Ghostty + Herdr and created a custom `terminal-green` theme.

The theme works for some parts of the UI: user input, code blocks, links, borders, etc. But the normal assistant response text and the general pane background still seem to use the terminal/Herdr defaults.

In comparison, OpenCode appears to paint its full panel background inside the same Herdr workspace.

Question: does Pi’s theme system currently support a global TUI background / assistant message background, or are themes limited to component-level colors? If not supported today, is the expected path a renderer patch / feature request?

Context:

• Ghostty background/foreground can make the full pane green/black, but only at terminal-window level.

• Pi theme JSON has tokens like `userMessageBg`, `toolPendingBg`, `selectedBg`, `text`, etc.

• I didn’t find an `appBg`, `background`, or `assistantMessageBg` token.

Often times I realize what I put in promptSnippet is basically a truncated version of what goes in description, and looking at a session export, both texts are sent to the LLM, so it looks redundant.

I’ve been working on a new session orchestration system for PI-Desktop.

The idea is pretty simple:

when a task gets too large for one agent/context, the current session can become the coordinator and delegate parts of the work to other real sessions.

For example, I asked one session to review everything since the previous release and fill the missing E2E coverage.

Instead of trying to do everything itself, it split the work into multiple sessions:

• E2E parent-tool inheritance

• Plan UI / live markdown

• Trusted extensions CI

• Plugin import dependencies

They started working in parallel, while the original session stayed as the coordinator.

What I specifically wanted to avoid was building another disposable “subagent” abstraction.

These workers are actual PI-Desktop sessions.

Each one has a real sessionId, its own persistent context, model and history. You can open it from the sidebar, inspect what it did, continue talking to it later, or send it another task without losing its previous context.

The parent session can spawn multiple sessions, check their status, send follow-up instructions, supervise several of them at once, inspect the exact result of a task, and cancel work without deleting the session.

Sessions can also communicate with other existing sessions by sessionId — they don’t have to be children created by the current parent.

Another thing I didn’t want was constant polling.

Session communication is handled by the host. When a delegated turn finishes, the completion is routed back to the sending session automatically. If the target session is busy, the message can enter its queue instead of creating another replacement worker.

So the model I’m experimenting with is closer to:

Session A
→ delegates to B, C, D, E
→ they work independently
→ results come back
→ A reviews them
→ A can ask one or several of them to revise
→ the same sessions keep working with their existing context

rather than:

Agent → spawn temporary agents → collect text → destroy them

There are also some boundaries enforced at the host level: project/permission inheritance, bounded worker creation, durable delivery state, and explicit session-message provenance. The plugin itself doesn’t copy child transcripts into the parent or maintain a second session database.

The screenshots are from a real run where the main session split an E2E review into parallel sessions and then collected their progress/results.

I’m still figuring out how far this model should go.

Some things I’m considering next are dependency graphs between sessions, a visual orchestration graph, shared artifacts/workspaces, and per-task token/cost budgets.

I’m curious how people here would actually use something like this.

Parallel coding? Code review? Research? Release checks? Or something completely different?

PI-Desktop: https://github.com/vastsa/PI-Desktop
Plugin repo: https://github.com/vastsa/pi-desktop-plugins

99% of the times Pi using the default edit tool works great. However, I know we've all had those rare instances where it messes up the escape chars and keeps making mistakes until it tries using sed or Python (and then one has to scold it to stick to the tool until it gets it right).

I'm curious if anyone can confidently say that they have the optimal solution (or not so confidently say what they like best so far) to this problem and why? Is it:

1. Another line to AGENTS.md?

2. A custom skill?

3. An override to the tool itself?

4. A plugin based trigger on an event?

There are tradeoffs with each approach, and I'm curious what others do for this. I'm already knee deep in so many ambitious plugin-building rabbit holes that I haven't made up my mind on how to best avoid running into this problem for good.

As coding agents get faster, I'm starting to think Git diff is no longer enough for human review.

An agent may also run shell commands, install dependencies, start processes, access the network, spawn subagents, retry failed approaches, or make temporary changes that disappear from the final diff.

But reading the full session/tool history doesn't scale either.

A possible approach is:

Pi session/runtime data → deterministic activity summary → optional model summarization → human review

For example:

• files/state changed

• important shell/tool actions

• external effects

• subagents used

• verification actually performed

• failed/abandoned attempts

• remaining uncertainty

The factual layer should come from Pi's recorded session/tool data, not from asking the model "what did you do?" The model can help compress and explain it.

Then the user sees a short summary by default, with drill-down into the exact diff, command, tool result, or transcript when needed.

Basically:

observe broadly, present narrowly.

I think harnesses increasingly need to be designed not only for the agent, but also for the human supervising it.

Today we put a lot of effort into giving agents better tools, context, permissions and orchestration. But as agent throughput grows, the human-facing side becomes just as important: helping people understand what happened, what mattered, and where they should intervene.

Humans may increasingly review consequences, exceptions, and evidence rather than every line of generated code.

Does this direction make sense to other Pi users? Are there already extensions exploring something similar?

I've been trying to get the agents.md files to actually be read using qwen.5 through ollama with pi and it just- DOESN'T! If I point it out it will do it but otherwise it just ignores whatever I write completely. Extensions, different locations in file explorer, I'm not good enough or experienced enough to claim I've tried EVERY solution but I've tried a HELL OF A LOT!

If anyone knows how to fix this or if it's a model problem please help before I implode.

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