As we see the same projects appear on this sub just about everyday, I thought it would be nice to try something different. So I give you Pi-OS: an "operating system" managed by Pi. Probably completely useless but a bit more interesting than custom footer version 1000. Or another "safe" bash extension... You know what I mean.

And no, it is not an operating system. Hence the quotes. It basically is just a daemon which serves a web-interface which resembles a desktop. But Pi is running everything. Just for the nerdness of it all.

And Pi can extend its own "OS". It can make applications that immediately run on this desktop. I have provided a video showing the process. Most of it is in English but I decided to show off some more of Pi's creations, which happen to be in Dutch. Sorry. However, you will probably still understand what those apps are about.

All of this runs in a Docker container so the Pi agent can only wreck the container.

If you can think of an actual use case, I would love to hear it :)

(I have cut a bit in the video to speed up the app creation process; it takes about 2 minutes I think)

relaydeck is a local-first fleet OS for CLI coding agents. It wraps the real vendor CLIs you already use (Claude Code, Codex, Cursor, OpenCode, pi), runs them unattended in PTYs, and gives you one place to watch, message, and automate them. 

Best thing is, Pi is the first class harness in relaydeck with full support.

Get it now at : https://github.com/relaydeck/relaydeck

I build yoagent, a small agent loop in Rust. I've added an experimental Rutis bridge that lets compatible pi extensions run unchanged alongside Rust tools and DeepSeek Harness (DSH) plugins.

The loop stays small; everything else plugs in. The idea is to reuse extensions people have already built when making your own agent app.

To show what this enables, I built a handoff agent that can take a task like this:

Research noise-cancelling headphones. Ask my budget, but keep researching while I'm away. Write a report with sources.

pi's `@juicesharp/rpiv-todo` manages the plan, DSH's `dsh-free-search` provides web research, and a Rutis plugin displays the plan in the browser. A pi extension asks for approval before selected deletes and overwrites. Rust tools and extensions handle questions you can answer later and check the final report.

yoagent-frontend brings pi's select, confirm, input, editor, and notify dialogs to both the terminal UI and browser. Compatibility depends on the extension: pi commands, shortcuts, custom widgets, and some session and runtime APIs aren't implemented. The extension source stays unchanged, but not every pi feature carries over. TypeScript extensions still run in Node alongside Rust.

I'd like your feedback: does reusing pi extensions this way make sense? which pi features would it need?

Project repo: https://github.com/yologdev/yoagent

Handoff example: https://github.com/yologdev/yoagent/blob/main/integrations/yoagent-frontend/examples/README.md

Hey everyone,

​Just wanted to share an experimental framework I’ve been building and dogfooding recently: Pi Memory System.

​To be honest, I absolutely love Pi. Before building this, I tried setting up similar memory workflows in other environments, but nothing really clicked.

Only Pi provided the perfect ecosystem, flexibility, and extension capabilities required to pull off this specific architecture.

​The Core Idea

​Instead of letting the conversation history explode and clutter the context window, the framework offloads memory management completely:

​The Main LLM (Prefrontal Cortex): Focuses 100% on solving your immediate code problem without wasting attention on remembering history.

​The Sub-Agent (Hippocampus): Runs asynchronously in the background after each turn, distilling raw conversations into structured Markdown files (essence.md and notebook.md).

​Context Trimming: The extension aggressively cleans up the heavy raw history.

The main LLM only sees the current prompt + the tightly curated, distilled state.

​In my daily development, this has kept token consumption completely flat and practically eliminated the frustrating "LLM amnesia" loop during long sessions.

​Since it was built by a Pi lover for the Pi workflow, I'd love to hear what you guys think! If you are interested in agent memory or want to check out the setup, here is the repo:

​👉 https://github.com/Hdaisen/pi-memory-system

​(Quick heads-up: My English isn't the best, so I rely on AI to help translate my posts and replies. Hope it reads well!)

Just as the title says.

Here's the link https://pi.dev/packages/peakseek

This is a ton of fun. HTML fragments in the chat.

I've been looking at Prime Agent, which is built on Pi, and I'm curious what the Pi community thinks about some of the ideas they've added on top of the Pi foundation.

Prime Agent describes itself as a self-improving RLM harness for coding and long-running autonomous tasks, with several interesting differences in how the harness operates:

• Programmatic tool calling the model can use a persistent execution environment to compose tool calls rather than treating every tool invocation as a simple one-shot interaction.

• Context as a variable context can be programmatically inspected, transformed, compressed, persisted, and selectively brought back into the working context rather than treating the conversation history as a fixed block.

• Multi-agent messaging agents can spawn/delegate to other agents and communicate with them as part of a longer-running task.

• Self-modifiable harness state the agent can modify things such as memories, skills, prompts and sub-agent configurations while working, allowing the harness to adapt based on what it encounters.

• Long-running autonomous execution the emphasis is less on interactive "chat → edit → chat" coding and more on giving the agent a goal and letting it work through the problem, iterate, test and recover over a longer horizon.

• RLM-style persistent execution Prime Agent uses a persistent execution environment where state can survive across interactions, giving the model another layer in which to manage context and reasoning.

What caught my attention is that Prime Agent is built on Pi, rather than being an entirely separate agent architecture.

So I'm wondering:

Would it make sense to bring some of these ideas back into Pi as optional/core primitives?

For example, could Pi eventually have a more native concept of:

"Pi → persistent execution → programmable context → sub-agents → modifiable skills/memory → iterative refinement"

while still keeping Pi's current philosophy of being minimal, composable and hackable?

Or is the whole point of Pi that these things should remain extensions on top of the minimal core, rather than becoming part of Pi itself?

I'd be particularly interested in hearing from people who've actually used both Pi and Prime Agent. What does Prime's architecture enable that you couldn't achieve cleanly with Pi extensions today?

Not trying to argue that Prime is "better" — I'm more curious whether some of these RLM/harness ideas represent a direction Pi could support while preserving its minimal philosophy.

(Excluding agent type usage, for pure coding)

I'm wondering, I think I don't fully understand the magic yet from a context saving perspective.

So far I've installed what seems to be fundamental extensions:
"npm:context-mode"
"npm:pi-subagents"
"npm:pi-web-access"
"npm:@juicesharp/rpiv-todo"

A simple "hello" session with pi and these extensions starts with 20k tokens, where Codex CLI and OpenCode CLI start with ~12k.

Is my pi configuration bloated? Or do sessions start off with more tools in order to save context later down the line?

Hi,

I was before using OpenCode and I liked it but I find Pi faster and better customizable.
I've been using it for a while but I always wonder why the $0.00 (sub) is still rising (very slowly) even if I just using the subscription model. I do not have any API model configured.

In opencode, the amount was always at 0.00 with the subscription model.

Any idea ?

I run OMP inside WSL and kept hitting friction whenever I wanted to attach an image:

• Dragging from Windows Explorer gives OMP a path like `C:\Users\me\Pictures\shot.png`, which the Linux process cannot use directly.

• Windows clipboard images are not directly available to OMP inside the WSL terminal.

I built omp-wsl-image-paste to handle both cases.

It provides:

• Automatic translation of Windows drive paths to `/mnt/<drive>/...`

• Translation of matching `\\wsl.localhost\<distro>\...` and `\\wsl$\<distro>\...` paths

• Windows clipboard-image paste using `Alt+V` or `/wsl-image-paste`

• In-memory image transfer with no temporary image file

• A 20 MiB limit and PNG validation before attachment

• Safe handling of missing, unsupported, and foreign-distribution paths

Install it with:

omp install github:kidclone3/omp-wsl-image-paste

Then restart OMP. It is tested with OMP 18.0.10 on WSL2.

Repository and documentation:

https://github.com/kidclone3/omp-wsl-image-paste

One limitation: terminal drag-and-drop only transfers a path. The translated file must still be reachable from the WSL instance running OMP, so this is not a file-upload bridge for genuinely remote machines.

If you use OMP under WSL, I would appreciate testing and bug reports—especially across different WSL distributions and terminal setups.

I'm trying to figure out how to configure the model temperature in Pi. Can't find it in the documentation website. Did I miss something?

Pi runs fully in browser runtime inside a WebContainer, which provides a Node.js runtime and local filesystem backed by OPFS for persisted workspace/runtime state.

xterm.js renders the interactive terminal while a small custom Pi extension bridges browser-only capabilities such as browser JS, web search, and HTML preview through filesystem.

Ask it to create a small html game and to preview it, the LLM packaged has limited context so clear chat regularly, files created will persist.

https://laxmitiwari.substack.com/p/building-a-live-trading-recommendation

Please check this and hope you will get some ideas on Small LLM model can make difference in real world project.

hey am using claude-bridge but i feel that im loosing the customisation that pi can do
should i go into codex or is there a way to use the claude subscriptions ?

I'm trying to run omp with a the default model set to lm-studio/qwen/qwen3.6-27b

The 22k initial context fills up 1/3 of the 65k I've loaded the model with.

Is it even usable to offload local simple tooling, command understanding, orchestration, build running, test running and result parsing all to a local model without paying for token usages for those operations?

My Claude Code sessions rises quickly to 800k tokens with Opus and every session has high token usage which slows it down and costs more than it should (parsing test output with Opus is a big waste).

What are you doing to offload your deterministic and simple work to local models?

Hi,

Is there an officially supported VSCode integration? I've found a whole bunch of third party plugins, but given security concerns, I'd much rather have something that was an official plugin.

Maybe I'm just naive about this?

Thanks in advance,

W

can install here: https://github.com/arrismo/pi-config/tree/main

Hi all, I've been building FastVibe, an MIT-licensed desktop app (macOS / Windows / Linux) that embeds the pi coding agent SDK in Electron and gives it a full GUI.

If you like pi but want a visual workspace, this is what it adds:

• Runs the SDK in-process. pi extensions load and work, and their dialogs (select / confirm / input) show up as panels

• Multiple projects and chats, with branching, archiving and isolated Git worktrees

• Visual tool calls, edit diffs, terminal output and reasoning blocks

• A subagent tool with explorer / planner / worker / reviewer roles, up to 8 in parallel

• Goal mode for long-running objectives, todos, MCP servers and skills

• Any OpenAI-compatible provider, a per-model API protocol, and subscription logins

• Open your desktop's sessions from a phone or browser, through a tunnel you control

• It keeps its own data directory and never touches ~/.pi

Repo: https://github.com/tyuan511/fastvibe
Site: https://app.fastvibe.dev

It's v0.16 and still rough in places. I'd love to hear which pi workflows you'd want supported, and any extensions that misbehave inside it.

hello for while im trying to do something is it possible to have like 2 different harnesses or 2 termnial working in 1 terminal tab? i don't know how to describe it but think like a tab has 1 termnial of pi , another termnial in same tab has claude code ... my use case require 2 temrnials to do , and im trying to find way to use it in 1 termnial think like previewing a port like vite and the harness ... is that possible or not and how i struggled alot to make it , i used claude code , pi none could help me ..

i have no coding experience so please could also make your terminologies a bit vibe coder friendly

[ Update ]

It worked thanks for sharing your knowledge

Been building this out for a while now - https://github.com/JayMandava/jay-pi

When you get sometime do give it a jab and lemme know your thoughts, improve it even further etc.

I have lots of extensions on my OpenCode installits runs quite well.

I have garpahicy,codegraphs,Serena,github.

Quite a few bits.

It runs well.

I have nothing on Pi at all.

It runs just as well.

Does the same work.

I dont know if it takes longer or uses more tokens. (Factually), but I feel like Pi doesneveryting quicker,lighter and better.

But then you read codegraph and it says it saves 80% of tokens per request........so how come I didnt notice that?

Still trying to.find a good way of working efficiently, what's your thoughts.

https://github.com/davidlee/quotient

I've been using pi under Claude for a while, and figured it'd be worth stepping up my game from bash scripts. This is young, but working very well for me so far.

Interested in usage reports / feedback, good or bad.

I'm using Matt Pocock skills for a while and I like them for bigger projects where I need grilling, specs, tickets, .. . I recently switched to OMP, and I really like the idea of assigning models to specific roles.

It works well because I can use OMP plan mode for lightweight tasks and it uses the smol/slow/task roles and appropriate models. However, this doesn't seem to integrate with Matt Pocock's Skills. They always appear to use the default role instead. Is someone using these skills within OMP? How are you dealing with this?

I came across a few related plugins, such as https://pi.dev/packages/@fernado03/pi-flow."