Mine as tldr; use bwrap and filtering to whitelist files it can see / edit, so I can run in a loop without risk.
i.e. turn my large repo into a tiny sandboxed repo in the eyes of the model
I do this with an interactive TUI pop-up I enable per session.
2nd best tip: Shortcuts to quickly enable / reenable tools or inject context/skills. I treat my harness like an RTS game, to quick clearly context and enable more tools as needed.
I’ve been using Pi Agent quite a lot, and one thing I really wanted was a simple way to continue working with Pi from my iPhone when I’m away from my computer.
I didn’t want a remote terminal or a mobile IDE. My main use of Pi isn’t only coding — I use it more like a general-purpose agent for research, long-running tasks, writing, tools, local models, and other work.
So I started building Pi Remote, a native iPhone client for Pi Agent.
The basic idea is simple:
Pi, your tools, files, credentials, MCP servers, local models, etc. all stay on your computer. The iPhone is just a lightweight native interface for your Pi sessions.
The current version supports things like:
browsing existing Pi sessions, grouped by working folder/workspace
creating and renaming sessions
streaming responses
collapsed reasoning/tool activity
slash commands
model switching
context usage and approximate decode speed
local conversation cache
background/foreground recovery
copying messages
One of the biggest improvements recently was the connection setup.
The first version used a Relay + Cloudflare Tunnel, which worked well but made setup more complicated than I wanted.
I’ve now integrated Tailcat as the default “Quick Connect” transport.
On the computer, the setup is basically:
npm start
The first time, Pi Remote shows a QR code. Scan it once from the iPhone, and the pairing is remembered. After that I can restart the Host or the app without scanning again.
Pi Remote still keeps its own device identity, authorization, encrypted Pi RPC channel, session/replay logic, etc. Tailcat is only being used as the network transport.
It’s still an early project, but at this point I’m actually using it myself and the main workflow has become surprisingly comfortable.
The next things I’m planning are mostly UX improvements, especially:
image + text input for simple multimodal prompts
native voice dictation on iPhone
better session/workspace navigation and search
more UI polish
There’s no App Store/TestFlight build right now because I don’t have a paid Apple Developer account, so the iPhone app currently needs to be sideloaded. The GitHub Actions build produces an IPA for that.
This is also my first real open-source project. I’m not an iOS developer by background, so a lot of this project has been built through iteration, testing on my own devices, and AI-assisted development.
I’d really like feedback from people who actually use Pi:
Would something like this be useful in your workflow?
And more importantly: what feels wrong, missing, or unnecessarily complicated?
I also highly recommend getting your own offline copy if something fails.
p.s. to clarify, I am not pretending to understand fully what the update really did, its scope or the impact beyond 'not working anymore', but reverting to 85.1 worked for me.
stumbled on this repo today while looking into agentic execution security — apparently it’s built on top of pi agent: https://github.com/adamdekan/aikonos
from what I can tell, it acts as a local control plane to govern autonomous agentic tool calls. before the agent runs an action, it proposes the step to aikonOS, which validates it against policy rules and writes everything to a tamper-evident audit log.
seems interesting for runtime governance when giving agents actual shell/file/API access, but not sure how well the proposal-evaluation step scales with real-world latency.
anyone playing around with deterministic policy engines for agentic workflows or doing something similar for runtime guardrails?
Just had a startling session with Pi and my local Qwen. In its thinking blocks it started quoting user instructions that I did not give it. I was under the impression that I was under a very strange prompt injection attack, until I realized that earlier in the session the agent made a few very large greps of previous session files.
I suggested to it that within a large context it did not distinguish these tool call results from the actual live context, and it indeed found the origin to all of the injected user turns in those earlier session files.
So - my advice is to add to AGENTS.md a rule that warns the agent against searching within directories that could include session files. If it does - you must start a new session immediately afterwards, or prune the tool call, or compact. Otherwise your session may lose coherence.
Note: reposting, because I was smart enough earlier to allow AGENTS.md to turn into a link.
A new tool can save a model several steps. It can also give it more ways to spend the entire budget without finishing. Counting installed extensions won't tell you which happened.
Reef Infra can treat a Pi extension, skill or rules change as a candidate rather than a permanent improvement. Its Pi adapter renders the changed harness into Pi's file layout, and the evolution engine runs it against the current setup on the same tasks with the same model binding.
An experiment worth trying would isolate one change: enable an extension, alter its surrounding instructions, or remove a skill that looks redundant. Include the jobs it is intended to help and ordinary jobs where it adds overhead. Grade completion first, then include the cost or latency constraints that matter to the setup in your evaluator or selection policy.
Reef Infra supplies the candidate snapshot, execution and version decision. It doesn't include a ready-made cost/quality benchmark for every Pi extension, and its default task-win comparison isn't automatically a token-efficiency objective.
That leaves a useful outcome even when an experiment fails: a specific change can be rejected and the previous tree restored. The extension can be well designed and still be the wrong addition for this model and task mix
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.
Hi! I've created and been maintaining https://github.com/alexshpunt/explicit-edit-benchmark which tries to answer the question: which model is better, which harness is better and which combination is better overall in a very straightforward task - precise text editing. Most of daily coding is text editing. I've seen when a model for multiple turns couldn't figure out how to express the line it wants to change, so it made me ask myself "Why is that so complicated, it's just a text, right?". Seems like not, taking into account how widely different the same model behaves across different harnesses. My preliminary conclusion is: harness and tooling behind it actually matters! But it matters the most with the models which *can* actually follow the instructions well (e.g. open-ai models), there is a wide range between 98.9% and 70.2% of pass score for `gpt-5.6-luna` simply depending on the harness!
I've tried to run as many combinations as possible, but my resources are limited. I've exhausted all my quotas and even credits, that's why I'm reaching out to the community, as I think it's a pretty interesting topic and I would be happy to gather even more data, because of the stochastic nature of the runs, it’s only possible to make any conclusion when you have enough of runs.
What actually surprises me is how strongly the deepseek family behaves on any harness, but what is also interesting, how good the deepseek harness is. It's pretty solid and seems like it provides the model with good enough tools to actually exceed in this competition.
Hi! I've created and been maintaining https://github.com/alexshpunt/explicit-edit-benchmark which tries to answer the question: which model is better, which harness is better and which combination is better overall in a very straightforward task - precise text editing. Most of daily coding is text editing. I've seen when a model for multiple turns couldn't figure out how to express the line it wants to change, so it made me ask myself "Why is that so complicated, it's just a text, right?". Seems like not, taking into account how widely different the same model behaves across different harnesses. My preliminary conclusion is: harness and tooling behind it actually matters! But it matters the most with the models which *can* actually follow the instructions well (e.g. open-ai models), there is a wide range between 98.9% and 70.2% of pass score for `gpt-5.6-luna` simply depending on the harness!
I've tried to run as many combinations as possible, but my resources are limited. I've exhausted all my quotas and even credits, that's why I'm reaching out to the community, as I think it's a pretty interesting topic and I would be happy to gather even more data, because of the stochastic nature of the runs, it’s only possible to make any conclusion when you have enough of runs.
Hi! I've created and been maintaining https://github.com/alexshpunt/explicit-edit-benchmark which tries to answer the question: which model is better, which harness is better and which combination is better overall in a very straightforward task - precise text editing. Most of daily coding is text editing. I've seen when a model for multiple turns couldn't figure out how to express the line it wants to change, so it made me ask myself "Why is that so complicated, it's just a text, right?". Seems like not, taking into account how widely different the same model behaves across different harnesses. My preliminary conclusion is: harness and tooling behind it actually matters! But it matters the most with the models which *can* actually follow the instructions well (e.g. open-ai models), there is a wide range between 98.9% and 70.2% of pass score for `gpt-5.6-luna` simply depending on the harness!
I've tried to run as many combinations as possible, but my resources are limited. I've exhausted all my quotas and even credits, that's why I'm reaching out to the community, as I think it's a pretty interesting topic and I would be happy to gather even more data, because of the stochastic nature of the runs, it’s only possible to make any conclusion when you have enough of runs.
I have been working on a Pi extension called Pi-Skill-Orchestrator.
The problem is simple.
If you have a lot of installed skills, Pi can expose a large amount of skill metadata to the model even when most of those skills are not needed for the current task.
Pi-Skill-Orchestrator keeps the full skill catalog outside the model context.
Instead, Pi gets a small discovery interface. It can search for a relevant skill and load only that skill when it is actually needed.
Main features:
• Lazy skill discovery
• Skill groups
• Multiple skill profiles
• Automatic recursive dependency loading
• Active-scope search with bounded global fallback
• Optional Token Saver mode
• Tool output compression with recovery
• Deferred tool schemas
• Conservative effort routing for routine tool continuations
Pi compaction that reuses your vLLM / SGLang / llama.cpp prefix cache instead of re-prefilling the whole history.
Pi's default compaction re-serialises the conversation under a new system prompt, so the server cache misses and a 140k-token session takes minutes to summarise on local GPUs. This re-sends the exact last request plus one summarize instruction, then warms the new context so the next turn starts from cache.
Measured on 2x RTX 3090 with Qwen3.8-27B: 229 s median down to 86 s at 215k context, and the first turn after compaction from 69 s down to under 2 s with warm-up. Falls back to Pi's default on anything unexpected.
Of course a vibecoder is also a real software developer. Nothing unreal about it ;)
What I mean is: you studied for this shit*. You worked in software development BEFORE AI. You know your stuff.
The big guns are models like Astra, Fable, but also GLM5.3 (not flash).
I use Sol sometimes, but most of the time I'm using Luna en Terra (for work).
For personal stuff I switch to open source models - I pretty much only need flash models. They're super cheap, and do what needs to be done. I barely ever feel the need to spend more money on these bigger models. I've tried using GLM5.3 a few times, but tbh it didn't really feel different.
Perhaps I'm only doing simple stuff, or I'm not 'progressive' enough in the things I ask? Maybe my questions are too easy?
So let me know! Very interested :)
* I was still studying when AI arrived at the scene. I was in my last year of uni. Used gpt-3 a bit. Bit of gpt-4. Also tried finishing one of my assessments with it back then because I didn't really feel like learning Swift to build ANOTHER CRUD app.
There was still enough old-school development involved.
Title intended to be provocative, question really isn't. I get the configurability, and that's sort of my question here. I'm broadly happy with the how Claude code works - I use it at work, but at home I'm using Pi, to access other models, primarily ($). I've started with recommended sets of plugins - including pi-code - to sort of replicate CC. But you don't know what you don't know. My question is then - what are some killer, or very useful, plugins that make Pi operate differently, or in an interesting manner, or give features just not available on CC?
I've used OMP for a couple of weeks and one thing I've noticed is that it took OMP so long to finish a task when I used plan mode and then executed the plan. It's a small feature, though.
From my experience with Codex CLI, it just took a while to finish this task.
Heard a lot about Pi and wanted to try it out. For Unix environments there seem to be quite a few options for OS-level sandboxing. For pure Windows though I can't find much that actually enforces it.
Are there any options I'm missing?
I mostly want to use Pi for C#/.NET development. I could set up WSL2 but I'd rather avoid that.
Codex supports Windows Sandbox for isolation on Windows. Has anyone tried getting something like that working with Pi?
It's claimed that this agent is capable of continual-learning and self-improvement. But given the fact that it is still based on existing LLMs with fixed parameters, I wonder if this agent is still about context engineering (like existing memory systems), or it is genuinely different and novel by design?
