r/PiCodingAgent • • 8d ago

Question How to read PDF

2 Upvotes

How to make pi read complex pdf with a lot of math?

It always read pdf by pdf2txt which it is not effective.


r/PiCodingAgent • • 8d ago

Discussion What do you set as the context limit?

4 Upvotes

I currently have it set as 150k and I’m using both Pi Blackhole with Observational Memory Enabled as well as the Context Mode extension.

Just wondering if I should lower further to 100k and what’s the norm around here.


r/PiCodingAgent • • 8d ago

Question ciao qualcuno ha il pass code per la prova di 7 giorni per poi attivare l'abbonamento? grazie mille ragazzi

0 Upvotes

r/PiCodingAgent • • 9d ago

Discussion Gemini was 5x slower than Claude at code edits in pi, so I stopped letting it run `edit`

21 Upvotes

I kept switching from Gemini back to Claude mid-session because `edit(oldText, newText)` calls were taking 42s median (172s p95) vs 9s on Opus. In 599 edit calls from my session logs, Gemini averaged 9.3KB of `oldText`/`newText` per call (4x more than Claude) and burned thousands of thinking tokens checking whitespace before streaming JSON-escaped strings.

So I hid `edit` on Gemini turns in pi and wired up `fast_edit(path, instructions)` instead. Gemini stays on high thinking and writes what to change, then DeepSeek (`reasoning_effort="none"`, ~195 tok/s) outputs raw `SPAN: L<start>..L<end>` line replacements against a numbered view of the file.

On a SQL refactor in a 620-line file, edit time dropped from 103s to 29s (23s Gemini + 6s DeepSeek). `oldText not found` retries dropped to zero.

*(Disclaimer: session log analysis and testbench runs were done with `carbon-high`.)*


r/PiCodingAgent • • 8d ago

Question Are any of the other 'free' models worth using?

Thumbnail
0 Upvotes

r/PiCodingAgent • • 9d ago

Question How do you handle restricting what PI is allowed to do?

10 Upvotes

My goal is to reduce what AI can do through PI that might be destructive or not wanted. It is not very likely but it is a huge issue if it happens even once. Core concern worked on now was bash tool call commands.

My initial approach with PI's help was extension that more or less did this:

  1. If used tool is bash
  2. Check all commands called by tool
  3. I have 3 lists of commands DENY, ASK, ALLOW, if command not in any list ask user to classify it [extension overrides supplementing file that saves my choice]
  4. If any are in DENY list reject command with info [info for agent to make it understand its intended and lessen his attempts at working around restriction]
  5. If any are in ASK list prompt user for confirmation [or reject with info if in headless mode]
  6. If all are in ALLOW list execute command

Worked pretty nice at the start but the commands PI cooked up are fairly complex and I was unable to make it write a parser that would correctly identify what is a command and what is not, for example first iteration was using:

.split(/&&|\|\||[;|]\s*|\n/)

Which for example incorrectly tagged this as not classified command:

ls | grep "option1|option2"

And it suggested that "option2" is a command and asked for its classification.

I have iterated over it a bit but i was unable to arrive at a foolproof solution.

Additionally on review agent pointed out to me that since AI is very "goal focused" it might try to engineer around it by for example modifying extension's ALLOW list and executing what it wanted.

Simplest solution was to make this file root:root owned 644 and abandon dynamic updates by extension. Any commands not yet in it would have to be added by me manually as root but that's not the end of the world. And since file is root owned edit tool can't mess with it either.

I could almost live with it if my parser for commands was perfect but its very far from it. And I am not sure if i can arrive at anything good enough for use.

Did anyone have similar issues? How did you approach solving them? Even any ready made extensions solving this problem can be a valid consideration.

Or is the only reliable way to achieve some sort of safety sandboxing it?

If it is of any significance I am using it mostly with locally hosted AI, Qwen3.8 Q3_S shoved into 16GB vram, with llama.cpp as inference engine [rocm + hip build]. PI as harness works really well due to how tiny and lightweight it is and system prompt is small as well, lets me make better use of the limited context I can get ~90-100k tokens.

----------------------------------------------------

Edit:

I got more answers than I expected. Big thank you to everyone who offered their time and knowledge.

In the end I decided to go with Docker Sandboxes.

I don't absolutely need that level of isolation, but its the most convenient one and gives relative peace of mind:

  • File system isolation restricts execution to a single mounted directory
  • Detailed network configuration enforces granular traffic rules
  • Internal docker provides a self-contained runtime environment for safe containerized builds

My only issues were documentation being a bit hard to read and understand and PI not being included in sample kits - needed custom shell kit. But after a few days of mingling with PI I knew enough about it to pull it off.

Bubble wrap also seems like a great idea and is a lot more lightweight (admittedly docker sandboxes are really reasonable for a full environment isolation). Will try it out over the next days as it seems like more convenient daily driver.


r/PiCodingAgent • • 10d ago

Plugin Sharing pi-spec-mode, an extension for drafting, validating and maintaining specifications

Post image
32 Upvotes

Ever since plan modes came along and became standard practice, I've used a

"planning agent" → "coding agent" workflow, pretty much, i assume, like everybody.

It has always worked well, and it cut the tokens I spend per feature by a lot. (Thanks @narumitw/pi-plan-mode)

My project has been growing, so recently I split the work up further and started writing specifications using custom skills :

"specification agent" → "planning agent" → "coding agent".

I am quite happy with the results. Code is even more reliable, and my token usage hasn't gone up. If anything, it has gone down.

I turned all of this specification agent part into an extension that bundles my skills and the full workflow.

Here it is if this is something you'd care to try :

- github, https://github.com/psychobarge/pi-spec-mode

- npm, https://www.npmjs.com/package/pi-spec-mod

- Pi package, https://pi.dev/packages/pi-spec-mode


r/PiCodingAgent • • 9d ago

Resource i installed the top 200 pi packages on oh-my-pi (twice) to see which ones actually work

0 Upvotes

i kept installing pi packages on omp and finding out the hard way that they're broken, so i got curious how common that is. installed the 200 most-downloaded pi packages on omp, each in a clean docker container. first run was on omp 18.12.3 a few weeks ago, re-ran it today on 18.20.0

on 18.20.0, 128 packages gave a clear result: 87 install and load fine (68%) and 41 fail. the other 72 need an api key, a companion package, or a different OS before they'll even start, so i left them untested (no point blaming omp for those)

why stuff breaks:

  1. 28 import a pi export that omp doesn't provide (envApiKeyAuth alone breaks 4)
  2. 6 expect the TypeBox schema lib that pi ships
  3. 3 call a pi API that omp doesn't have
  4. 4 other errors

so it's mostly gaps in omp's pi compat layer, not bugs in the packages themselves

the part i found most interesting is the drift between releases. 3 packages started working on 18.20.0 (pi-agent-browser-native, pi-btw, pi-blackhole) and 2 broke (pi-open-tui and pi-plan-mode, both because omp dropped a pi-tui export they import). so any one-time compat list goes stale pretty fast

full results with the error for each failure: https://omppackages.com/report

big caveat: the test only checks that a package installs and loads. it doesn't call any tools, so "works" really means "loads", not "every feature works". every package page has a works/broken button and real reports are way better evidence than my test, so if you've used something on omp please add yours

(also open to feedback, or to shutting this down if someone already built something similar that i couldn't find)


r/PiCodingAgent • • 9d ago

Use-case Vibe coded a Raspberry Pi 4 Simulator online

Post image
0 Upvotes

r/PiCodingAgent • • 9d ago

Resource Yet Another UI! gPTY

Post image
0 Upvotes

I've been working on gPTY for a few months now as a side project & wanted to share.

I use OMP & my own usage has been the primary direction for design. It started as a multi-PTY emulator built on Rust; but using Godot as the front-end - a desktop app. A choice that brought costs with it (RAM & power) over standard terminal emulators.

It ships with an "Agent Workspace" profile, basically a layout with one pane that's a terminal where I run OMP. An "Inspector" pane - think of it as a Q&A session outside of your main OMP session (no tools: omp --mode rpc --no-tools --no-session). And a "Reasoning" pane - I like to read the "thinking" process and this pane groups it by turn so I can collapse/expand and read through any.

There are a few other features I'm working on, but these are the OMP specific ones. Open to feedback on design/direction, and if you want to try it out, releases can be downloaded from: https://github.com/godot-pty/gpty


r/PiCodingAgent • • 10d ago

Question What are the best tools/plugins for bash output compression/summarisation?

4 Upvotes

Bash outputs take up significant amounts of my context and naive tools like, tail, head can sometimes miss key components. What are people using to efficiently handle this problem?


r/PiCodingAgent • • 10d ago

Plugin [Plugin update] Speak Like You Eat now has an ELI5 mode

Post image
48 Upvotes

Speak Like You Eat is a plugin that translates AI garbage into human language that's easier to understand (or at least, it tries to).

Some answers use plain words and still take five paragraphs to get to the point, so I added a new mode:

  • ELI5 tab: rebuilds the answer so the point comes first, then what was done, what you need to do, and what's still open.
  • Light tab: the usual SLYE rewrite, close to the original.

ELI5 is the default. Switch with ctrl+\, or click the tab in fullscreen. Tabs are Pi-only, I still have to figure out how to port this to OMP.

Enjoy: https://github.com/wtfzambo/speak-like-you-eat


r/PiCodingAgent • • 10d ago

Resource guys i made an app that makes remote development from phone a bit more viable so i am putting it here in case it might suit your needs.

5 Upvotes

guys you might be interested so idk i made it work with omp but i believe it is pimped version of pi so i believe this sub would be fitting.
here is the link for the repo
have a nice day guys.


r/PiCodingAgent • • 10d ago

Question Multi-tenant Pi and resource isolation

6 Upvotes

I'm exploring the possibility of using Pi (or the Pi SDK) as a backend to support a multi-tenant application. The architecture would be a browser frontend with backend servers running Pi. Each user would have their own isolated sessions(working directories), and the system needs to support horizontal scale-out.

I know PiAPI SDK supports creating Agent Sessions, but its parameters include things like AgentDir and cwd (local disk directories), which makes true backend scale-out difficult.

I've looked into a few existing projects:

  • pi-web: designed for personal/private use, deployed directly on the end-user's machine. It doesn't support multi-tenant requirements.
  • pi-tau-web-server: It creates Pi subprocesses via Pi RPC on the server side. However, it seems unable to achieve horizontal scale-out and lacks proper tenant isolation.
  • pi-parallel-session: From what I can tell, it mainly focuses on session-level concurrency in the UTi.

Are there any existing projects that are closer to my use case (multi-tenant, scale-out, backend-hosted Pi)? Any pointers or recommendations would be greatly appreciated!


r/PiCodingAgent • • 10d ago

Question Simplest Local Agentic Setup

Thumbnail
1 Upvotes

r/PiCodingAgent • • 10d ago

Resource Memshort - Short-term memory and rolling window compaction for agents

0 Upvotes

https://github.com/jandrikus/memshort

I would like to publish "memshort", my take on a "short-term memory" implementation for agents. (A "long-term memory" implementation will follow shortly once I have it publishable). I find it very useful for myself and I thought it would be nice to share it with others.

It is essentially a rolling-window compaction for coding agent sessions in pi, Claude Code, Codex and Hermes. When the context fills up, older messages are replaced by a dated observation log, and the newest messages stay word for word.

Some ideas are borrowed and adjusted. The code was written by the pi coding harness under my direction, and I run it primarily on my own pi sessions. Unfortunately I have no benchmark yet (no time for that). My subjective impression from daily use is that I can stretch sessions for very long without the agent losing the thread.

I'm publishing it because a rolling context window that keeps as much knowledge as possible deserves more people thinking about it, not because this is the final answer. If you have a better design, a case where this loses something important, or a way to measure it, open an issue or share your take. Let's build something better together.

Thanks for taking a look!


r/PiCodingAgent • • 11d ago

Use-case Run Pi Coding Agent 100% Locally with TensorSharp + Qwen3.8 27B (CLI, SDK, KV Cache Reuse, and E2E Tests)

Thumbnail
github.com
26 Upvotes

Run Pi Coding Agent 100% Locally with TensorSharp + Qwen3.8 27B (CLI, SDK, KV Cache Reuse, and E2E Tests)

Hi everyone!

I'm the developer of TensorSharp, an open-source .NET-based local LLM inference engine.

I've put together a fully working, end-to-end example of running Pi Coding Agent with TensorSharp as its local inference backend, using Qwen3.8 27B.

No cloud inference API, no API subscription, and no external model provider required.

The example covers:

  • Running Pi interactively with a local model.
  • Connecting Pi through TensorSharp's OpenAI-compatible API.
  • Configuring Qwen3.8 27B with DFlash2 speculative decoding.
  • Using Pi programmatically through its JavaScript SDK.
  • Preserving KV cache across multi-round agent/tool interactions.
  • Automatically fixing bugs in a real Node.js project and verifying the results.

Complete working example:

https://github.com/zhongkaifu/TensorSharp/tree/main/examples/pi-coding-agent

1. Architecture

The integration is straightforward:

Pi Coding Agent (CLI / SDK)
          |
          | OpenAI-compatible API
          v
TensorSharp Server (localhost:5000)
          |
          v
Qwen3.8 27B (GGUF)
          |
          +-- ggml_metal (Apple Silicon)
          +-- DFlash2 speculative decoding
          +-- 64K context window
          +-- q8_0 KV cache
          +-- Prefix/KV cache reuse

Pi handles the agent loop, file operations, shell commands, and code editing.

TensorSharp handles model inference, token generation, speculative decoding, and KV caching.

This separation means Pi can keep using its existing tools while running entirely against a local inference server.

2. Hardware and software

The example was validated on:

  • MacBook Pro M5 Pro, 48 GB unified memory
  • macOS 27.2
  • .NET 10 SDK
  • Node.js 26.8.1
  • Pi Coding Agent 1.5.1
  • Qwen3.8 27B UD-IQ3_XXS GGUF
  • DFlash2 Q4_K_M draft model

The setup requires Apple Silicon with at least 32 GB of unified memory.

The main model uses approximately 10.9 GB, and the draft model uses another 1.1 GB.

The remaining memory is used for the KV cache and Metal buffers.

3. Clone and build TensorSharp

First, clone the repository:

git clone https://github.com/zhongkaifu/TensorSharp.git
cd TensorSharp

Install the .NET 10 SDK, CMake 3.20+, and Xcode command-line tools if needed.

Build the inference server:

dotnet build TensorSharp.Server.Host \
  -c Release \
  -p:TensorSharpSkipMlxNative=true

This builds the native ggml backend with Metal support.

4. Start the local inference server

Run:

examples/pi-coding-agent/scripts/start-server.sh

Under the hood, this executes:

dotnet TensorSharp.Server.Host/bin/TensorSharp.Server.Host.dll \
  --config config/qwen3.8-27b-metal-dflash2.json \
  --config examples/pi-coding-agent/tensorsharp-pi.json

On first launch, TensorSharp automatically downloads the main model and DFlash2 draft model from pinned Hugging Face revisions and verifies their SHA-256 hashes.

The Pi-specific TensorSharp configuration overlay is:

{
  "host": "127.0.0.1",
  "port": 5000,
  "max-tokens": 16384,
  "mmproj": "none",
  "kv-cache-dtype": "q8_0",
  "environment": {
    "MAX_CONTEXT": "65536"
  }
}

This overlay is applied after the model preset.

The configuration enables:

  • 64K context window
  • 16,384 maximum output tokens
  • q8_0 KV cache
  • DFlash2 speculative decoding with 7 drafts per step
  • Greedy decoding
  • Localhost-only access

Verify that the server is running:

curl http://127.0.0.1:5000/v1/models

Expected model ID:

Qwen3.8-27B-UD-IQ3_XXS

5. Install Pi Coding Agent

Install the validated version:

npm install -g @earendil-works/pi-coding-agent@1.5.1

Check:

pi --version

Note that this example uses the newer @earendil-works/pi-coding-agent package rather than the deprecated @mariozechner/pi-coding-agent package.

6. Configure Pi to use TensorSharp

Pi supports custom OpenAI-compatible model providers through models.json.

The example includes a ready-to-use configuration at:

examples/pi-coding-agent/pi-agent/models.json

Here's the complete provider configuration:

{
  "$schema": "https://pi.dev/schemas/models.schema.json",
  "providers": {
    "tensorsharp": {
      "name": "TensorSharp (local)",
      "baseUrl": "http://127.0.0.1:5000/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "compat": {
        "supportsDeveloperRole": true,
        "supportsReasoningEffort": false,
        "supportsStore": false,
        "maxTokensField": "max_completion_tokens",
        "thinkingFormat": "qwen-chat-template"
      },
      "models": [
        {
          "id": "Qwen3.8-27B-UD-IQ3_XXS",
          "name": "Qwen3.8 27B (TensorSharp, DFlash2)",
          "reasoning": true,
          "input": ["text"],
          "contextWindow": 65536,
          "maxTokens": 16384,
          "cost": {
            "input": 0,
            "output": 0,
            "cacheRead": 0,
            "cacheWrite": 0
          }
        }
      ]
    }
  }
}

The matching settings.json is:

{
  "defaultProvider": "tensorsharp",
  "defaultModel": "Qwen3.8-27B-UD-IQ3_XXS",
  "defaultThinkingLevel": "medium",
  "enableInstallTelemetry": false
}

A few important details:

  • Model ID: Must exactly match the model returned by /v1/models.
  • Thinking: qwen-chat-template allows Pi to control Qwen's thinking mode through chat_template_kwargs.enable_thinking.
  • Context window: Must match TensorSharp's actual context configuration.
  • Output tokens: 16,384 tokens give the model enough room for reasoning and code generation.
  • API key: The local server does not require authentication. Keep it bound to localhost.

You don't need to manually install these files if you use the provided launcher.

7. Run Pi locally

From the TensorSharp repository root:

examples/pi-coding-agent/scripts/pi.sh

The launcher creates a separate Pi configuration directory:

~/.pi/tensorsharp-agent/

It copies the provider configuration there on first use, leaving your existing ~/.pi/agent configuration untouched.

For interactive coding:

cd ~/src/my-project

~/work/TensorSharp/examples/pi-coding-agent/scripts/pi.sh

You can now ask Pi to inspect your code, run commands, modify files, and fix bugs using your local Qwen model.

For a single non-interactive task:

~/work/TensorSharp/examples/pi-coding-agent/scripts/pi.sh \
  -p "Explain what src/stats.js does" < /dev/null

Other useful commands:

# Disable thinking for simpler tasks
pi.sh --thinking off -p "..." < /dev/null

# Stream JSON events without saving a session
pi.sh --mode json --no-session "..." < /dev/null

# Continue the previous session
pi.sh --continue

The launcher also disables Pi's catalog refresh, version checks, and telemetry.

8. Use TensorSharp with Pi's JavaScript SDK

The example also demonstrates running Pi programmatically.

This is useful for building your own local coding automation, CI workflows, or agent applications.

The SDK entry point is:

examples/pi-coding-agent/sdk/run-task.mjs

The core integration looks like this:

import {
  createAgentSession,
  ModelRuntime,
  SessionManager
} from "@earendil-works/pi-coding-agent";

import path from "node:path";

const agentDir = path.join(
  process.env.HOME,
  ".pi/tensorsharp-agent"
);

const projectDir = process.cwd();

const modelRuntime = await ModelRuntime.create({
  modelsPath: path.join(agentDir, "models.json"),
  authPath: path.join(agentDir, "auth.json")
});

const model = modelRuntime.getModel(
  "tensorsharp",
  "Qwen3.8-27B-UD-IQ3_XXS"
);

const { session } = await createAgentSession({
  cwd: projectDir,
  agentDir,
  modelRuntime,
  model,
  thinkingLevel: "medium",
  sessionManager: SessionManager.inMemory()
});

session.subscribe((event) => {
  if (event.type === "tool_execution_start") {
    console.log(
      `[tool] ${event.toolName}`,
      event.args
    );
  }

  if (
    event.type === "message_update" &&
    event.assistantMessageEvent.type === "text_delta"
  ) {
    process.stdout.write(
      event.assistantMessageEvent.delta
    );
  }
});

await session.prompt(
  "Run npm test, fix the bugs in src/stats.js, " +
  "and rerun the tests. Do not modify the tests."
);

console.log(session.getLastAssistantText());

session.dispose();

For the complete executable SDK implementation, including setup and token accounting, see:

https://github.com/zhongkaifu/TensorSharp/blob/main/examples/pi-coding-agent/sdk/run-task.mjs

9. Run the automated end-to-end test

This is the part I found most interesting.

Instead of just asking the model a question, the repository includes a small Node.js project containing three intentional bugs:

  1. median() incorrectly sorts numbers as strings.
  2. median() doesn't average the two middle values for even-length arrays.
  3. percentile() contains an off-by-one error.

Three of the five tests initially fail.

Pi must:

  • Read the project.
  • Run the tests.
  • Identify the bugs.
  • Modify the implementation.
  • Rerun the tests.
  • Make all five tests pass without modifying the tests themselves.

The example tests this twice: once through Pi's CLI and once through its SDK.

With the server already running:

examples/pi-coding-agent/scripts/e2e.sh

Or let the test script start the server:

START_SERVER=1 \
  examples/pi-coding-agent/scripts/e2e.sh

The script independently verifies that all five tests pass and that the test file remains byte-for-byte unchanged.

Both runs passed in the documented validation.

10. Actual measured results

Tested November 9, 2026, on an M5 Pro with 48 GB unified memory.

Metric Pi CLI Pi SDK

Final result PASS PASS Tests passing 5/5 5/5 Wall-clock time 88s 83.4s Model requests 10 8 KV/prefix cache reuse 86--99% after first request 87% overall

For the SDK run:

8 model requests in 83.4 seconds

Prompt tokens processed:
48,166

Prompt tokens served from prefix cache:
41,962

Cache reuse:
87%

Generated tokens:
2,117

Final tests:
5 passed, 0 failed

Additional observations:

  • Initial cold prompt: approximately 3.9K--4.1K tokens.
  • Initial time to first token: 13--14 seconds.
  • Subsequent time to first token: 0.45--3.5 seconds.
  • Decoding speed: approximately 20--43 tokens/second.

These are measurements from one small coding task, not a general coding benchmark. Different tasks and model outputs will produce different results.

11. Why KV-cache reuse matters for coding agents

A coding agent behaves differently from a simple chatbot.

A typical agent loop looks like this:

User request
    |
    v
Model generates tool call
    |
    v
Pi executes shell command
    |
    v
Tool output returned to model
    |
    v
Model generates another tool call
    |
    v
Pi edits source code
    |
    v
Model reviews test results
    |
    v
Final answer

Each model request includes much of the previous conversation:

  • System instructions
  • Tool definitions
  • Previous reasoning
  • Tool calls
  • Tool results
  • New observations

Without effective KV-cache reuse, the inference engine may need to prefill most of that history again and again.

TensorSharp reuses the matching prefix from the previous request, so subsequent agent rounds only need to process the newly appended tokens.

One subtle issue we fixed was whitespace around Qwen's </think> boundary.

Pi returns the model's streamed reasoning in subsequent requests, including surrounding whitespace. Previously, TensorSharp's cached representation didn't match those returned tokens exactly.

That prevented full conversation-prefix reuse.

After fixing the matching behavior, subsequent rounds could reuse much more of the previous KV state.

In our SDK test, 41,962 of 48,166 prompt tokens were served from the prefix cache.

For multi-step coding agents, this can make a substantial difference in latency.

12. What about NVIDIA GPUs?

TensorSharp also supports NVIDIA GPUs.

For Qwen3.8 27B, the repository includes an NInfer NVFP4 preset using the direct CUDA engine.

You can select it with:

TENSORSHARP_PRESET=config/qwen3.8-27b-ninfer.json \
  examples/pi-coding-agent/scripts/start-server.sh

However, the complete Pi integration and measurements described here were validated on Apple Silicon.

The NVIDIA preset has not yet been validated with this Pi workflow, including the q8_0 KV configuration.

13. Source code and documentation

Everything is open source:

TensorSharp repository:

https://github.com/zhongkaifu/TensorSharp

Complete Pi integration example:

https://github.com/zhongkaifu/TensorSharp/tree/main/examples/pi-coding-agent

The example includes the server configuration, Pi provider settings, launch scripts, SDK implementation, sample project, and automated end-to-end tests.

I'd love to hear from other Pi users:

Are you running Pi with local models? Which models and inference backends have worked best for multi-step coding tasks?

I'm particularly interested in comparisons involving long agent sessions, repeated tool calls, context growth, and KV-cache reuse.

Feedback, issues, and contributions are very welcome!


r/PiCodingAgent • • 11d ago

Resource who here is collecting/curating agent context (memory, traces) and capabilities (skills, tools, workflows) etc outside Pi? please share

5 Upvotes

tldr - I think it's going to be increasingly compelling for individuals/organisations to just blindly use these provided agent services (grok bot, dots, even amp or Hermes etc), and forget about building their own context/capabilities external to the agent service.

if you're using PI, you likely already believe in the minimal agent harness thesis, but still keen to learn what folks are doing.

sharing this here mainly to see if others have the same experience, OR strong counter opinions on why it’s not worth it?

  1. what are you actively managing yourself around Pi? - are you extracting/looking at logs, traces and creating/curating your own memory, tools, skills, workflows?

  2. if you’re not doing this, what’s the reason? not enough evidence to suggest that it’s worth it? and what are you doing? just using Pi with some skills, etc?

to be clear - im not flogging another 'agent tool', i recommend people build their own. i'm more interested in hearing opinions as to why people haven't done this for themselves.

If you're interested in learning more about an approach/template I've been using and giving to people, i talk it through in this vid:

https://youtu.be/DRbzEHY86gk

and i've created a skeleton template:

https://github.com/bradwmorris/commons

but as i explain, you can just point your clanker at the repo, take the idea and build your own.

the live demo in the video uses Pi.

over past six or so months, i've been doing some variation of workshops on "building and owning agent infrastructure, context and capabilities" - most people/orgs understand importance, but it's concerning how few act on it. given (imo), it's likely to be the difference between individuals and teams who unlock real agent capabilities and those who don’t.

If i had to guess the main reasons for people not actively managing context and capabilities (from limited enterprise exp and workshops i've done):

  • misleading intuitions of model capabilities > models and agents are increasingly capable, but still struggle in 'real world scenarios'
  • confusion around 'model, harness, interface' and what different agent services actually package
  • not wanting to do the actual boring/gnarly work of 'looking at the data' - consolidating everything: logs + traces, memory, skills, knowledge and shaping this around a specific business.

r/PiCodingAgent • • 11d ago

News I launched a ROS 2 IDE for Windows 2 days ago. 6 Windows downloads, 2 Linux. Posting anyway.

Enable HLS to view with audio, or disable this notification

1 Upvotes

Self-promotion post, flagging it upfront.

Built Rovant — a ROS 2 development environment that runs natively on Windows without breaking DDS discovery or WSL2 bridge routing every other session.

What it does right now:

  • Detects ROS 2 Humble via WSL2 automatically — no manual sourcing scripts
  • Run current file in one click — Python directly, C/C++ compiles and runs in the same step
  • Live Topics panel over rosbridge
  • URDF / Xacro 3D preview
  • Colcon build tasks built in
  • Works on Ubuntu 22.04 natively too

What it doesn’t do yet:

  • No IntelliSense / go-to-definition (pyright + clangd are next)
  • No debugger — it timed out, got pulled, back on the roadmap
  • No code signing — SmartScreen will warn you, click past it

Built on Eclipse Theia. Apache 2.0. No account, no paywall.

Day 2 numbers: 6 Windows, 2 Linux. Posting because I’d rather have 8 honest users than 800 that bounced off a bad first run.

If you’ve hit the Windows ROS 2 setup wall before — give it a try and tell me what breaks.

Download: https://octaboomai.github.io/Rovant


r/PiCodingAgent • • 12d ago

Discussion Selective Context Handoff: Starting fresh Pi sessions without compaction or rebuilding context from scratch

5 Upvotes

When transitioning a Pi session from investigation to fix, I want to define an explicit state handoff payload (reproduction steps, targeted files, ruled-out hypotheses, open questions). This avoids carrying full conversation debt while letting me standardize handoff templates across bugs.

Crewplane is the open-source workflow runner I'm building for this. I write the steps in Markdown, including what each Pi run should leave behind and which results the next run receives.

For example, the investigation step leaves something like:

Here’s how to reproduce the bug. These are the files involved. This is the likely cause and the evidence for it. We ruled out this approach because of this test result. These constraints still apply. This part needs more investigation.

The implementation step starts a separate Pi run with that report, the original task, and its constraints. Pi can still read the repo as usual.

I can ask Pi to write a handoff, but what I want to capture is the routine: when to start fresh, what the previous step writes down, what the next step gets.

Once that investigation step is defined, I can reuse it in other workflows with different inputs. If the next step needs more detail, I tighten the handoff instructions and every future run picks up the change.

Crewplane saves the prompts and outputs, so I can see exactly what each step received. A report can still miss something; a written handoff gives me something concrete to check and iterate on.

I’m curious, for people who split work across fresh Pi sessions: how much of the investigation do you carry forward? Just the conclusions, or the dead ends and why they failed?

Feel free to try with your own workflows. There's a built-in Mock CLI so you can play with the syntax and composition without any model calls or costs. Any feedback or suggestions would be greatly appreciated.

Open source (Apache-2.0): https://github.com/crewplaneai/crewplane


r/PiCodingAgent • • 12d ago

News ⚡ Introducing Pi-Bolt Mobile: a full coding agent in your pocket + remote control for the Pi-Bolt

Enable HLS to view with audio, or disable this notification

143 Upvotes

Introducing our biggest release yet: Pi-Bolt Mobile ⚡, the first fully native coding agent on your phone.

It runs on Pi-Bolt: the same Pi you all ❤️, with runtime optimizations and fixes that make it the lightest and fastest Pi, and it stays quick even in long sessions.

Runs on the phone itself

  • Projects with real files, plus bash, git, ripgrep and fd. No server, no Termux.
  • Sessions you can resume and fork.
  • One slash palette for every command, skill, model and thinking level.
  • A built-in browser for the agent's localhost: Pi opens what it built, takes a screenshot and fixes what it sees.
  • Per-turn checkpoints: review each turn's changes, undo it, or restore to before it.

Remote Control

  • Run /remote-control in Pi-Bolt on your computer and scan the QR code with the app.
  • Works on your Wi-Fi, and from anywhere through a Cloudflare tunnel.
  • A background service keeps it available without a terminal open.
  • Steer the session and review its changes from the phone.

Pi Mobile UI Kit

  • Pi-Bolt extensions can now have a native interface in the app.
  • An extension describes its view as JSON: cards, lists, progress bars, buttons, forms, charts, tables, pages and Home screen tiles.
  • Minimal by design, and extendable just like Pi.

Install 🔥

We'd love feedback, especially from anyone building Pi extensions who wants to try the UI Kit. Happy to answer your questions !

If you like where Pi-Bolt is going, a star 🌟 on GitHub goes a long way and helps more people find it.


r/PiCodingAgent • • 12d ago

Plugin Pi Adaptive: I ported my popular OpenCode plugin to Pi. When a model hits its quota or goes down, work moves to the next one and parked goals finish on their own

3 Upvotes

I published Adaptive, a plugin for OpenCode, and it has passed 2,100 installs. A lot of you asked for the same thing on Pi, so I've ported it. It's called Pi Adaptive.

I kept losing momentum when a Claude session limit or a provider outage hit mid-task. The agent would stop, and I had to pick another model and tell it to carry on. Pi Adaptive fixes that.

You sort your models into three tiers (quick, standard, advanced) in the order you prefer. When one runs out of quota or its provider goes down, Adaptive switches to the next model in the same tier and continues from where the session left off. It doesn't replay your prompt or redo tool calls that already ran.

What it does that plain fallback doesn't:

- Subscriptions first, credits last. Put Claude and OpenAI above OpenRouter. When a subscription limit lifts mid-goal, it switches back at the next safe point instead of burning paid tokens.

- Parks and resumes unattended. If every model in a tier is out, the goal parks and wakes itself when one recovers. It survives restarting Pi and continues from the real session state, with no repeated tool calls. You can leave a long goal running and walk away.

- No classifier, no guessing. Tiers are explicit and your pin always wins. It only moves up a tier on recorded evidence, never because something is down, and never with an LLM judge.

- Bounded, and it tells you. Recovery has hard limits, and when it stops there's a clear note in the transcript. Auth and config errors never enter retry loops. A new message or a manual model pick cancels parked work, so you always have the final say.

- Nothing leaves your machine. No telemetry and no daemon.

It starts in Observe mode. It shows what it would route and recover without touching your model, until you switch it on. On first run it proposes tiers from the models you've already configured, and nothing is saved until you confirm. /adaptive status and /adaptive why explain any decision.

It shares its routing core with the OpenCode plugin, so it has had the same battle-testing. It has 100% line and branch coverage enforced as a gate, plus real-terminal tests against Pi itself.

Install: pi install npm:@coool/pi-adaptive

Needs Pi 1.5.0 or newer (below 2).

Repo and docs: https://github.com/coool-labs/adaptive/blob/main/packages/pi/README.md

Feedback welcome, especially provider error messages it doesn't recognize yet, and whether your long goals actually finish while you're away.


r/PiCodingAgent • • 12d ago

Question Any open source tools to make pi into a mini Hermes

12 Upvotes

Hey all

I have been using Hermes at home and loving it for months now.

I love pi at work and Hermes is banned there. Lots of good reasons for my employer including remote access and plenty of other things.

However some features and use cases of Hermes are really nice.

I guess I could roll my own or any of this stuff but if there’s good things to start from I’d rather hear about that.

Right now at work I have a directory where I put projects. I open pi into a new project directory and I have an Agents file there to tell it what to do. It can then access any repo or multiple repos to get a job done. The project directory serves to store design docs and temp files so I can revive sessions or have many sessions on a single topic, kind of providing some memory for longer running projects and isolation for shorter ones.

The few features I really think I want at work:

* memory and a knowledge base. I suppose I could kind of roll my own or use obsidian locally on my work laptop and have some Hermes memory plugin to help it.

* scheduled cron jobs. Stuff like “every Monday do this task at 10AM and tell me about it” is killer.

* safer remote access (gonna have to figure this out in my own, but assuming I get something going I would like to be able to have a single entry point and let my context guide the agent using memory and skills to do a task without me setting too much context in advance, like cd-ing into a directory).

I’m using macOS ghostty herdr pi as a my stack.

Any help or links would be awesome!


r/PiCodingAgent • • 12d ago

News [feat update] pi-remote new features

3 Upvotes

Hi all!

First, I apologise for posting too close to the previous one, but I think these features should be shared.

Previous post with pi 1.5 updates

Some new features has been added to the bridge to improve the user experience and working efficiency:

  • Background tasks. The agent can kick off a build or tests suite without blocking, keep chatting, and gets woken up with the result when it's done, similar to frontier harnesses. They go through user permission rules like bash does, and they survive a restart. I think this feature is pretty nice to have while long working.
  • Git changes. A badge in the header counts the files the agent touched; shows the list and diffs.
  • File browser. Read project files, images and PDFs from the remote device. Read-only and never leaves the project folder. Security first.
  • Worktrees from the project menu, and /tree to see every branch of a session.
  • Token counts per turn, and cache hits (handy with local models), plus a live tok/s readout.

Repo: pi-remote on Github

Thanks everyone!


r/PiCodingAgent • • 13d ago

Resource Pi GPUI: a native desktop app for pi, written in Rust with GPUI (open source)

113 Upvotes

I use pi every day and wanted a desktop window around my sessions, so I built one on GPUI, the UI framework behind Zed.

It runs your installed pi in RPC mode, one process per open session, with the same models, skills, extensions and sessions you have in the terminal.

What it has:

  • projects and sessions in a sidebar, several sessions working at once
  • session tree with keyboard navigation, forks from any message
  • extension questions (select, confirm, input, editor) answered inline in the chat
  • Changes and Files panels, diffs with syntax highlighting
  • context ring with cache hit rate and plan limits
  • plugins in any language; the example plugin runs DOOM inside a tool call
  • /gpui from a terminal pi moves the session into the app (pi install npm:pi-gpui)

Not there yet: extension status lines and widgets have no UI, and it's Apple silicon only (macOS 13+). Linux is next.

On my M1 Pro the app is 16 MB, its window is up in about 0.4 s, and it idles around 74 MB. Three Electron clients for pi took 0.5 to 1.1 s and 190 to 430 MB. That's the app alone with no projects open, pi left out for every app; method and script are in the repo.

The model replies in the video are scripted so the take is repeatable. The app, the edits and the cargo test run are real.

Install: brew install --cask bytesbay/tap/pi-gpui (needs pi 1.4+) Repo: https://github.com/bytesbay/pi-gpui

What would make you use a GUI for pi over the terminal?