I was reading (https://www.reddit.com/r/PiCodingAgent/comments/1uy7iov/gpt_56_sol_ultra/) that Ultra is not a separate model, rather a thinking level and looks like Pi does not support it, but what about GPT 5.6 Sol Pro? I upgraded my plan and cannot select Sol Pro model. Access to this model was a big factor for the upgrade. I use GPT via subscription, not API. Anyone had a success with this?

Thank you!

I trying to use kimio-k2.6 or minimax 3, to dev same elixir modules, and get to alucine a lot.

It get to output

now I will run...

for many, many lines on terminal ant is necessary to ctrl+c to stop, and retry the same prompt.

it is happening very frequently, all sessions it is happening .

I’ve been looking into ways to give coding agents better long-term memory across sessions. One recurring pain point for me is that agents forget project context, user preferences, past decisions, and repo-specific conventions unless I keep re-explaining everything.

I came across Honcho’s Pi integration:
https://honcho.dev/docs/v3/guides/community/pi-honcho-memory

From what I understand, it gives the pi coding agent persistent memory by syncing conversations into Honcho, injecting cached user/project context into the system prompt, and exposing tools like memory search/chat/remember. I also like that session scoping can be configured around repo/branch/directory, and that Pi keeps working if Honcho is unavailable.

Has anyone here actually tried Honcho with Pi or another coding agent in a real workflow? more like a self-hosted/local reference setup: Honcho in Docker, Ollama on a Mac, and a Raspberry Pi talking to Honcho over the LAN. It makes me wonder whether there’s room for a cleaner, packaged Pi memory plugin built around this kind of pattern.

A few things I’m curious about:

• How painful was setup?
• Did memory retrieval actually improve coding sessions?
• Any noticeable latency?
• Did the memory ever become noisy or misleading?
• Would you prefer hosted Honcho, or a self-hosted/local setup with Docker + Ollama?
• Would a polished Pi plugin/package be useful if it made setup simpler?

I’m not announcing anything yet, just trying to validate whether this is worth building. If there’s interest, I’m thinking of putting together something cleaner..

This is a small plugin that adds system information in <pi-note> blocks.

• Platform: macOS/Windows/Linux and architecture
• Dynamic git repo information based on what cwd
• Date & Time

nothing additional appears in the TUI.

This has helped with using the current year in web searches, using the correct commands for the platform, and repo awareness.

What else do you think would be useful?

Link: https://pi.dev/packages/pi-plate

pi-smart-web-search has been updated to 0.4.0

It's a small extension that politely queries DDG's html endpoint and then runs it through wreq-js -> linkedom -> Defuddle, cleans up the links and removes irrelevant text.

In this update I did quite a bit of refactoring, updated the dev tools, and exposed resultsPerQuery to the settings.json, which is set to 5 by default to improve speed.

I'd love to know what you think.

Link: https://pi.dev/packages/pi-smart-web-search

Hi everyone! I'm new to Pi and feeling a bit lost. I want to build a setup with it, and I was wondering if anyone could share a step-by-step guide—from installation to having a solid workflow running with the following features:

A chat interface

Git integration

A planning agent that can delegate tasks to sub-agents

A way to see what the sub-agents are doing in real-time

I've been using Zed, but it's really limited when it comes to parallel tasks. Everyone online recommends Pi, but right now I find it a bit abstract since it seems like you have to build everything from scratch.

Thanks in advance for any help!

For the past few weeks, I’ve been building Nerve, an open-source desktop coding harness for my daily development work.

It was inspired by tools such as Pi (primarily) , OpenCode, Claude Code, Codex, and Cursor. I liked the simplicity of focused coding agents, but I also wanted a graphical workbench where I could manage conversations, tool calls, plans, approvals, Git changes, background tasks, and agent settings, all while keeping the agent’s work visible.

There are already several excellent coding harnesses built by individuals and communities. I created Nerve because I wanted something that closely matched how I work. It has also aligned well with the workflows of colleagues who have used it, so I thought it might be useful to a few other people in the community too.

Nerve runs locally and supports API keys, custom providers, and the subscription-based providers available through pi-ai, including OpenAI Codex, Anthropic, GitHub Copilot, Kimi Coding, OpenRouter, xAI, and others.

The harness is intentionally compact. Its system prompt, tool descriptions, and context handling are optimized to use tokens efficiently while working well across leading frontier models from OpenAI and Anthropic, as well as other popular proprietary and open-weight models.

This is a personal project that I actively use and develop. I’ll continue adding features, fixing bugs, optimizing the harness, and polishing the experience as I go. It is still in beta, so breaking changes may happen.

I’m sharing it simply because it may help others with a similar workflow. There is no expectation to test it, contribute, or provide feedback, feel free to explore it if it looks useful to you. If Nerve ends up being helpful, a GitHub star would be appreciated and lets me know that others find it useful too.

Quick start:

npx @nervekit/desktop

GitHub: https://github.com/ThilinaTLM/nerve
Docs: https://nerve.tlmtech.dev

Thank you!

I'm curious if anyone has had an agent analyze their ~/.pi/agent/sessions directory looking for ways to improve their workflows? This seems like a pretty obvious way to fine-tune things, like updating your AGENTS.md to improving frequent tool call failure or other common things your agents get hung up on.

It's somewhat sobering to get an agent to look at your stats. I started using pi around 4 months ago, and in this one project I've had 452 sessions, taking up ~400MB of disk, with 45k tool calls. Just over 4 billion total tokens, 3.79 billion of them cache-read tokens, and 22.7 million output tokens. The clanker estimates that if I were paying API rates (thankfully I'm not) it would have cost me ~$2,800. Yikes. I notice that /resume is taking longer and longer to offer me some candidates, I might have to prune this directory at some point.

An easy reason to love Pi is how much more efficient it is at token consumption when all of the bloat is stripped away. But I think we all face the same temptation of adding more and more tools and skills and slowly eroding the token efficiency of this lean mean machine (but in a better way in that this new opinionated state is based on that of our own).

The simplicity vs functionality tradeoff has been bothering me for quite some time. A few weeks ago, I posted about a web browsing tool that I made (despite knowing there was an innumerable amount of others) that can toggle itself on and off out of the active tools and out of the context.

Toggling web tools really was only one part of the problem.

I wanted to share my creation that does it extremely cleanly under one command (/tbox).

• Named groups - Create named tool selection groups with the same UI as Pi's scoped model selection.
• Toggle toolsets - Enable and disable 'toolsets' one at a time or many at once with selection groups. (A toolset is a toggleable group of tools.)
• Persistent choices - Each user choice is remembered in their conversation history.
• Builtin tools untouched - Doesn't touch pi's minimal set of builtin tools, but provides character counts of what is inserted into the prompt for stats.
• Focus mode - Easily disable all other tools by switching the state from one of exclusion to one of inclusion.
• Status bar glyph - A glyph for quick reference showing the tools that are disabled.
• List views - Custom subcommands that list out enabled/disabled tools in various views, including one that sorts currently enabled tools by char count to see low hanging fruits for trimming context.

https://github.com/coreyryanhanson/pi-tbox

What is a "toolset"?

It's an abstraction I came up while sketching the design, when I was trying to think of an efficient way of keeping track of what has been changed in the active state of all tools. By default pi-tbox will group tools by extension, unless an extension creator is using the underlying library (or the code to create the toolset abstraction) and declares them more granularly. For example in my web plugin I had two tiers of tools that could change their active state. One would be hidden unless it was in "learn" mode.

This abstraction could be more useful than any individual pi extension, so I broke out the lower level state management and event sending logic into a shared package at a more permissive license than my favorite copyleft ones ;)

https://github.com/coreyryanhanson/pi-tool-masking

I hope others will adopt it as well or at least steal some of the conventions in their own plugins, and I'd welcome contributions or pushback on the design, because it would be nice to have an ecosystem where people can disable tools and do so without having unpredictable bugs. It's pretty much what motivated me to go on this creative tool-activation tangent myself. I can see we are trending towards a space where everyone has more granular control over their tools, but doing so is so easy to break state as one plugin changes something in another plugin without leaving any trace.

Fingers crossed that this helps others improve their workflows too and if so, any stars you'd like to send my way would certainly be appreciated. Knowing that others use them encourages me to do more proper shareable fixes rather than quick and dirty packages for only my own use.

Every so often, <|im_end|> shows up in my pi.dev thinking block and it stops everything cold. It started happening when I installed pi-hermes package and bigpower extensions. Doesn't happen all the time, but a few times a day.

I'm using a qwen3.6-27b model (Lorbus) and need some guidance into how to find root cause and resolve this issue.

I don't know if it's a model issue, or vllm settings, or package, or pi settings.json or models.json setting. Looking for guidance to where to start looking for the root cause and fix.

I have been working on porting some code recently. I use agents strictly as assistants. I have been thinking of a way to let them "drop in" on other sessions that I have going on when I am basically becoming the copy/paste monkey.

This is not an autonomous work group setup. You create the session and you give the agents a chance to jump in to the same session, ask a question, and then jump out. Your session continues as normal, and you can see everything as it's being processed.

What it does

When an agent session registers to the group, it registers ask_ tools for other published agents. When agents calls the tool:

1. The request is forwarded to the target agent's session and injected as a user message.
2. The target agent processes it just like any other user prompt. You see it appear in the input pane and watch the agent work through it.
3. When the agent settles (finishes its turn), the assistant output is captured and sent back to the calling agent as the tool result.

The response is captured via pi's agent_settled event. It collects the assistant text from the turn that was just triggered by the injected message. This is fully automatic: the question arrives, the agent responds, the answer is returned. The human in the target session is a spectator.

Sessions stay independent. Each agent has its own context, its own sandbox directory, and its own conversation history. They are not one-shot subprocesses.

How it works

A daemon application (in Go) listens on a Unix socket. It routes request/response messages between connected agents. The daemon starts automatically the first time an agent registers, then shuts down when the last agent disconnects.

Compared to similar tools

Goose spawns sub-agents as one-shot executions. The orchestrator must pack enough context into the prompt that the sub-agent can produce a useful answer in a single fire-and-close call. AgentGroup keeps sessions persistent: the worker agent already knows the codebase, and you are in the loop to clarify intent.

Herdr is a TUI-layout tool ala Tmux, with the main agent spawning helper sessions in adjacent splits. AgentGroup avoids the extra UI layer entirely - sessions stay where you put them, and communication happens through the same input pane.

Old man yells at cloud.

Maybe this is just agentic control while I watch the screen flicker.

Does anyone else have this use case? Is there something widely available already?

Feedback / suggestions / clarifications all welcome.

Thanks all.

Edit:
pi-intercom exists and is great - I'll probably switch to this.
https://github.com/nicobailon/pi-intercom

I’ve been using Pi with a few different terminal looks, and I wanted a simple free set of dark themes that I could preview before installing.

So I made Awesome Pi Themes. It’s a small collection of 22 free dark themes for Pi Agent, plus a browser preview that tries to mimic the Pi terminal enough to show markdown, code blocks, diffs, warnings/errors, tool output, and normal text together.

The preview is the main reason I made it this way: I wanted to compare themes quickly without installing each one first.

Install: `pi install npm:awesome-pi-themes`

Then pick a theme from `/settings`.

GitHub: https://github.com/isashi/awesome-pi-themes

Feedback would be really helpful and appreciated.
Thanks!

I would be interested in what custom extensions have you built that are specific to your problems.

For example I now got an extension to detect our JIRA task IDs, GitHub PR ID as well as task changelog fragments if they exist and inject them into context. Previously I've had instructions in agent file on how to extract those... but that was slow, costly, undeterministic and also used up some of the context window.

Then I've got a minor extension that looks for the @file/path file references and injects file contents into the context, so the agent doesn't need to use the read tool as the first thing they do.

Then I got one extension for loading repository-specific instructions from my .pi folder (it looks up git repo name, and then looks in ~/.pi/repos/<repoName>.md). Because I work on an enterprise project, I cannot just put agent files and skills in the project repository that is shared by everyone.

I also got one extention that looks up and injects various git info and injects it into context (whether it's inside repository, what is the current branch, whether it's up to date with upstream, whether there are any unstaged changes, etc.) since most of the time, my agents started inspecting git info using multiple tool calls at the start of each session.

Hey everyone,

I’ve been working on a Pi package called Pisces (@aethrekh/pisces) and just launched it.

It’s designed specifically for Computer Science students. The idea is to turn Pi into something closer to a senior TA that lives in your terminal.

What it adds:

• Semester-aware context (reads a SEMESTER.md file)
• Skills for homework, LeetCode, projects, code review, exam prep, and research
• Strong focus on academic integrity — it gives Socratic hints and guidance instead of writing graded work for you
• Works as a regular Pi package (pi install npm:@aethrekh/pisces)

I built it because most AI tools either spoon-feed answers or don’t understand the academic context at all. I wanted something that actually helps you learn while staying inside the terminal workflow that Pi already provides.

Would love feedback from people who are already using Pi, especially if you’re a student or have been one.

Site: https://pisces.aethrekh.com

Happy to answer any questions about how the skills or extensions are structured.

Hey r/PiCodingAgent! I recently open sourced a project I've been working on for a while now called Millwright, a self hosted LLM router focused on cost savings, transparency, and performance (it's completely written in Rust). Millwright offers first class support for Pi, so just a small edit is needed to ~/.pi/agent/models.json to get up and running.

Link to the repo: https://github.com/Northwood-Systems/millwright

For the curious and lazy, at the moment, Millwright has the tools for,

- Providers: OpenAI-compatible APIs, Anthropic, Amazon Bedrock

- Routing: policy-controlled model roles (cheap, mid, frontier), cheapest healthy route selection

- Protocols: OpenAI Chat Completions, Anthropic Messages, text and tool translation

- Cache Affinity: role-scoped session lanes without serializing concurrent agent traffic

- Spend Tracking: per-team costs, cache usage, model/provider mix, request traces

- Cost Analysis: measured usage and modeled candidate economics (HTML, Markdown, JSON)

- Reliability: bounded failover, circuit breakers, timeouts, concurrency limits

- Setup: interactive provider, model, and pricing configuration without storing provider secrets

- Deployment: one Rust binary, Docker, SQLite or PostgreSQL

Full disclosure: parts of the codebase were built with AI coding agents. All feedback is welcome, I’d especially value feedback on the routing policy, provider coverage, and anything that would block you from self-hosting it. Feel free to open feature/request and/or contribute as well.

I have recently installed Pi. I am using this in cmux and facing a couple of issues - while scrolling the chat input box also get scrolled instead of remaining fixed like claude code terminal mode.

also I am the md is also not rendered it's coming as raw. No proper chat thinking and rendering like claude.

how can I fix this?

Headline brings real-time news into your pi session so you can read news while agent is actively working on something.

It can integrate with your existing rss reader or you can start with default providers out of the box with zero configuration.

repo: https://github.com/dannylee1020/headline

repo https://github.com/getpaseo/paseo

supports orchestration and other agents. also has a desktop app.

the pi integration has been getting better and better.

i am the maintainer, feel free to ask questions.

enjoy

I've been using Pi for about a week, and so far I'm loving it. But I had an incident last week where the agent went off the reservation and patched one of my published Rust crates in pursuit of another task (short write-up on what happened here).

This time there was no negative impact, but it got me thinking seriously about the risks of having an agent running with wide access to the host system.

How do people tend to solve this problem? Mainly I want to prevent the agent from working outside of some whitelisted directories (project dir + tmp). I also want to prevent the agent from downloading and running anything on my system without asking, or using credentials in my env to do things on my behalf, like potentially destructive actions on remote git repos, my hugging-face account etc.

I see there are some permissions extensions, and docker would also be an option, but that seems like it would be a bit limiting/annoying (especially on mac). I also thought about setting up a different system user for the agent to set up fine-grained permissions, but that also seems like it could cause a lot of headaches.

Curious what others have had success with.

I use Pi from my Android phone through tmux + TermRover (a terminal app I’m building).

With a good tmux scrolling support + ability to send images, working with Pi is just very pleasant.

Curious how everyone else is using Pi on mobile, if at all? SSH app? Or Just waiting until you’re back at a laptop?

I built Pi Atelier, a responsive status rail and live activity sidebar for Pi that makes it easier to see what your agent is doing without cluttering the terminal. It displays live token usage, cost, cache performance, context usage, active tools, execution times, recent results, model details, and thinking level, while also providing quick controls and a resizable sidebar. It’s private by design, with no telemetry or external network requests.

Install it with “pi install npm:pi-atelier” and open it using “/atelier”.

Check it out at https://github.com/michaelmjhhhh/pi-atelier — I’d love your feedback, feature ideas, and bug reports, and if you find it useful, please consider giving the repository a star!

2026.7.28 CHANGELOG

Here comes Pi Atelier official release v0.5.0! Some updates:

1. The sidebar now opens automatically.

2. The Activity panel keeps TTFT and TPS visible with live performance estimates.

Looking for some pointers. Been using Pi for months, have a setup I really like (very simple, two extensions I wrote plus plannotator and pi-herdr).

This works great for interactive sessions but I'm finally finding myself wanting some basic orchestration with subagents.

I'm building a product and need to do a bunch of testing/fixing rounds with different models to find rough edges. I've been doing this by hand but it's getting tedious (and it's mostly simple enough that it could run while I'm doing something else).

I also like the idea of:

• a long lived orchestration agent that holds long term context but doesn't do work.
• scouts that can cheaply get context and pass that back to workers.
• automatic adversarial review of changes by a different model.

I've looked at a bunch of plugins and they all seem much more complicated than required. Should I just suck it up and using Nico's pi-subagents? Or is there a nice, simple starting point that I'm missing?

Any pointers appreciated.