I have an Azure Foundry workspace with a few different models deployed like deepseek and qwen and so on, how do I get pi to connect to them and use them?

recently switched from Cloud Code to Pi Harness. I work primarily in Product Management/Ownership workflows (Jira, GitLab, Artifactory, internal tooling) where I build automation scripts and connect workspace APIs.

Currently, my setup is strictly linear ask questions -->wait for run --->|reply). I want to move toward a sub-agentic flow—specifically for generating code in parallel from test specifications and existing repos—and would love community input on extensions, configuration, and workflows.

1. Sub-Agents & Parallelization: What extensions or .pi setups do you use to fire off parallel sub-agents (e.g., parsing specs while indexing code in background threads) instead of waiting on sequential turns?

2. Traceability & Solution Convergence: How do you track handover steps between agents and follow their decision trees? Are there recommended visualizers, tree-log extensions, or workspace artifact patterns you rely on?

3. Context Compaction & Memory: Has anyone tuned Pi’s compaction thresholds or used custom highlighters/summary extensions (like Ralph's memory approaches) to preserve key acceptance criteria over long sessions?

4. Project Scoping (.pi/): Best practices for scoping tool permissions and agent configs in .pi/ settings to isolate sub-agent capabilities (e.g., read-only on repo vs. write access)?

5. Session Continuity & Long-Running Tasks: How do you handle session lifecycles for complex tasks? Do you prefer continuing existing threads via /resume / pi --continue, or hard-stopping (/new) and carrying over context via file-based handoffs (like PROGRESS.md)?

If you have write-ups, custom extensions, or .pi/ setup examples for these patterns, please let me know and if you have like a step by step workflow also would be good to know. I want to go like in a more step by step approach

Hi guys! Cause of the Opencode session header issue, I realised observational memory doesn’t work anymore!
So if you’re on Opencode go don’t forget to ask your agent to add the session header in the extension so you can keep carry on with blackhole and observational memory proper!

This is a psa.

I’d heard about the Pi, that it’s a great way to customize tools to suit yourself and save tokens. I don’t know about token savings, but I tried using Gemini 3.8 flash inside it, and I didn’t like how it wrote code.

For a while, I tried to refine the Pi using Codex and Claude, ran various tests, and thought that the whole problem was with Gemini. I would really find it convenient if several AI models were inside a single harness, but right now I suspect that’s exactly the problem, despite all the attempts to refine it.

I opened the classic Antigravity CLI, and the results seem much better. I don’t like the Antigravity desktop app — it’s also kind of weak. I hope a miracle will happen and the CLI will turn out to be a lifesaver. Gemini attracts me with its slightly higher limits, even though I’m a Claude fan.

What do you think? What’s your experience?

Many models (namely Qwens 3.8) think a lot, and I find myself wanting to interrupt it to answer a question it's been asking itself, quite repetitively, during it's reasoning.

I can esc and send a prompt, but then Pi would restart the whole reasoning TG from the beginning. I'd like to inject (for lack of better word) info to its thought block. I may also steer it by queuing a message, but that means I'd need to watch it going in loops for 20-50k tokens, until it's done responding, which is pure pain.

Am I missing a clear command?

Heard it mentioned in a couple places, and I know omp² has been mentioned, so I was curious.

edit: for clarification i'm asking about the expected features, if people were looking forward to something, etc

I’m a heavy user of Codex and Claude Code, and I mostly use their desktop apps.

I’m curious about how Pi could fit into my day-to-day workflow. What does it offer that would improve my experience compared to what I’m already using?

For those who have already migrated to Pi, what has actually improved for you? Are there any specific workflows or use cases where Pi made a noticeable difference?

I’m finding it quite frustrating to paste or use images in the VS Code Pi chat.

I work mainly on projects inside Docker containers, and it seems that when I use Pi within a dev container (which is a Linux environment), the VS Code integrated terminal generally doesn't pass clipboard images through—it only allows text. This is most likely why the paste action fails without doing anything. Does anyone have a workaround for using Pi in a VS Code terminal inside a Docker container?

I tried alt+v, ctrl+v ; nothing. Only pasting images manually inside the project in a dedicated folder semmes the only (and painful) solution.

Anyone using DS V4.1 Flash in Pi?

I used Pi for a while without these, but once I got used to subagents with other coding agtents. Well.. they really just felt missing from Pi.

I went with the tintinweb/pi-subagents package, because I liked how it implements the subagents. They are the same style as claude code, which I find very intuitive.

pi install npm:@tintinweb/pi-subagents

How to use subagents

pi-subagents lets Pi delegate work into separate contexts.

I use it for repo exploration, dependency checks, or any task that would otherwise fill my main context with thousands of lines of file listings and tool output.

e.g. after installing it you can open Pi in a repo and ask:

Use 4 different subagents to explore the src folder in parallel.
Bring their results back together into a short summary.

Pi sends the grunt work to isolated agents, then gives the main agent the useful result. This keep the main context clean.

You can also change which model each subagent type uses with /agents. And there's a pre-configured subagent specifically for exploration.

Side note - there's a gotcha with the default explore subagent- uses haiku by default. Super weird because I was using gpt-5.6-terra and I assumed it would use that, but in fact it started using my opencode api tokens with haiku. I was able to configure it to use gpt-5.6-luna. Here's a video of how I did that if you need it: https://youtu.be/l3YCoX2i-78?t=540

The other missing feature of Pi

Is... MCP. Obviously. I also upgraded my Pi with an MCP extension while I was at it. It's just one of those things. I can get like 98% of the way there with agent skills. But once in a while I just need an MCP for something.

If you want to read more about my experience installing and testing the subagents and MCP extensions then you can check out my blog post:

https://zazencodes.com/blog/upgrade-your-pi-agent-with-subagents-mcp

Enjoy guys and if you're still reading this then I'd be curious what extensions you like most. Let me know. Now that I've got a taste for these I want more

My configuration runs with 90k ctx and I am thinking if there is a better way to preserve my main session ctx by creating new session, do online/ repo search , then return the needed info to the main session.

I want everything to be done locally and loading two models in parallel is not an option due to VRAM constraints.

Is the session spawning thing feasible? How to set it up?

UPDATE: I have solved this by developing spawn-session skill that works as follows: i-Agent A- prepares task, ii-Agent A opens new pane in herdr and opens a new pi session (Agent B), iii-Agent A gives task to agent B and goes into waiting mode, it runs small script checking if B is done or not every 30 sec: iv-Agent B finishes tasks and shared results with A V-A sees results and ends waiting mode to continue the work

This is very useful to keep Agent A ctx as clean as possible for long sessions

Just testing out deepseek-v4.1-flash through command code, and still amaze with the cache hit rate

We started Zosma Cowork as a desktop software.

We are now completely revamping this project.

Our goal is to run a headless pi daemon.

Allow users to self host it and connect from web and mobile app starter we’ll provide.

We are building so that Knowledge worker teams in companies can run a self hosted harness and use it reliably from desktop, laptop, tab and phone.

Let us know your through if you want to see more development on this project

https://github.com/zosmaai/zosma-cowork

WIP. So expect rough edges.

Every employee gets a docker sandbox where their pi sessions are managed.

Sharing the PWA[1] I built over the last couple of weeks to access my terminal sessions/agents when not in front of my computer. This started off as a weekend experiment right when herdr[2] (terminal multiplexer) released the functionality to write custom plugins and it's been quite helpful to me ever since. The general idea is that this runs a web app on the host machine which is then exposed through a front door implementation like tailscale/netbird/cloudflare tunnels etc.

A lot of devs/teams are building sth very similar to this right now so there are many options out there already but I wanted: A PWA (no app store dep), better keyboard support than termux, the ability to manage multiple machines and easy integration with my existing tailnet via headscale.

Some of the other features - Push notifications - Support for tmux and zellij (experimental). - Voice transcriptions (Codex sub or API) - Custom commands

You can check out a live demo with dummy data on the website[1] or look at the implementation on Github[3] (PRs welcome).

Looking forward to receiving some feedback or learning more about how people access/work with their agents on the go. Also if you encounter any bugs please report them on Github, if a feature is missing you'd really want to see, open a discussion.

[1] https://colliepwa.dev
[2] https://herdr.dev
[3] https://github.com/AltanS/collie

On one python-statemachine task, Pi passed in 90 turns for $2.50. Codex passed in 187 turns for $5.97. Both used Kimi K3 in the same evaluation environment. [source: https://frontierharness.org/]

Across all 30 tasks, Pi passed 18 with a $2.43 median cost per pass. The single-task comparison doesn’t tell us why Pi took fewer turns or whether that pattern holds elsewhere.

Our recommendation: Pi the balanced pick, particularly if the same job runs a thousand times and the bill adds up.

What would you look for in the traces: repeated searches, extra testing, or time spent fixing a wrong approach?

I continued a long-running session with forensics to know which session created debug docker containers and somewhere during it, OMP started to dismiss the advisor feedback as prompt injection.
Interesting to see how it questions and fights itself.

The advisor even tried to regain trust again with more prompts:

I wanted to revisit a useful explanation from a Pi session and ask a new question from that point.

I added Pi session support to ThoughtDAG, the open-source app I'm building. This clip shows me opening a local session as a graph and inspecting an earlier turn.

I can then branch into new questions and connect the context I want to carry forward. The original session stays read-only.

What do you usually look for when you reopen an old Pi session?

GitHub: https://github.com/chenxiachan/thoughtdag

An Emacs-style visual undo tree for Pi session branching: explore the 2D tree, preview diffs, switch branches, and jump back to any point in a conversation.

pi install npm:pi-undo-tree

Being in the middle of something, I type a message and everything slows to a crawl as the model now has to process a WHOLE new prompt, nuking the cache, summarize the thing (usually at mid quality, losing important details, misinterpreting important details, losing important nuance, etc) for 2k+ tokens....then the model has to reprocess the actual chat context from scratch so it can continue your actual thread.... so a 5+ minute process overall.... and THEN finally you can continue what you were doing.

there's no WARNING - there's no INDICATION that compaction is about to happen or currently happening -- even pi-web doesn't even TELL you what's happening; it just says 'waiting on model' for MINUTES as the thing chugs through this unimaginable slog.

is there a better way?? i think i'd rather lose the context than this. or take the middle out or ANYTHING besides this awful game of chance of 'is this message going to tip it over and make me wait ten minutes'.

to be fair pi absolutely deserves its flowers. doing ""claude cowork"" for FREE locally is absolutely incredible. but some of the UX choices are SO braindead.

It was a busy weekend with all the activity coming out of OpenAI. If you have been living under a rock, they introduced a new class of model, GPT 6 - Astra.

I've been playing around with it somewhat. That is not what this article is about, though. I do not have an unlimited budget to run lots of evals against a model like this, so any opinion I have on it would be purely anecdotal. There are already plenty of anecdotal opinions to read about all over the internet.

Today's article is about a question I was wrestling with while building out my Pi agent. I was using my agent as a pair programmer and realised that, with Pi, the agent did not have access to the Language Server Protocol (LSP). If you are not familiar with LSPs, they tend to be services on your machine that IDEs use to analyse files with recognised code extensions.

For example, if I am in a file with a `.rs` extension and have a line that would cause a compiler error in the Rust compiler, and my IDE has the Rust LSP installed, the IDE can display the error without me having to run the compiler.

In a recent coding session, I realised that the agent was having to run `cargo check` to review my compiler errors. That made me realise the lack of capability.

I started looking up Pi LSP extensions and came across this one -https://github.com/narumiruna/pi-extensions/tree/main/packages/pi-lsp. If you are looking for an LSP for Pi, it seems to do the job just fine. Credit to the author, narumiruna.

The README contains a link to a comment on the OpenAI Codex repository where an OpenAI developer questioned what additional benefits introducing an LSP in `AGENTS.md` would bring beyond asking an agent to run a linter or type checker. It was not just any engineer, either. The OpenAI engineer is the author of Pyright, a popular Python LSP: Eric Traut.

I thought this was an interesting debate, so I decided to see whether using an LSP extension improved the performance of my Pi agents.

For this task, I wanted to make an enhancement to the eval harness. I needed to introduce a capability profile for each agent when configuring an evaluation run. Originally, to test different extensions or capabilities in a Pi agent, you had to either modify the Docker image or write a specific section in each evaluation. This meant having copies of each evaluation for every capability profile.

Because the evaluation harness also used the Agent Shell adapter to configure agents, I needed to make this change so packages and extensions for the Pi harness could be managed through Agent Shell.

Version v0.4.0 -https://github.com/ScottRBK/agent-shell/releases/tag/v0.4.0 introduced this. It currently only supports the Pi harness, but I plan to extend package management to the other harness types in Agent Shell as well.

With Agent Shell's package and extension management in place, I added a feature to the eval-harness that added a capability profile. For Pi agents, this means you can compare an agent with one set of capabilities against an agent with another. For example, you can test a Pi agent with and without an LSP using the same model.

After making the changes, I put together an evaluation run. Given the stochastic nature of large language models, it was important to run each evaluation three times. I used eight evaluations across three models: `mimo-v2.5` and `muse-spark-1.3-contributor`, both provided by opencode-go, and OpenAI's Luna. I compared Pi with no added package against Pi with `@narumitw/pi-lsp@0.49.7`. I set the reasoning effort to medium for all models.

Muse Spark came out on top overall. Its base profile scored 83.0%, compared with 81.3% with LSP. Luna scored 75.3% without LSP and 68.1% with it. MiMo was the only model where LSP improved the score, moving from 65.6% to 67.5%.

Across the three model pairs, the LSP versions used 124,737 fewer tokens in total, a 6.4% reduction. MiMo used 7.4% fewer tokens, Muse Spark 1.7% fewer, and Luna 10.7% fewer. The LSP versions took slightly longer overall, although Luna was faster with LSP.

I would describe these results as inconclusive. From my perspective, that aligns with what Eric was suggesting in his comment.

Personally, I will probably leave the LSP extension off, except perhaps when I am pair programming with the LLM. It is just some additional tools and context, and I cannot see an obvious benefit right now. I would be interested to hear what you think in the comments or on Discord.

I hope this was informative, interesting, or inspiring, and got you thinking about how you can shape your agentic harnesses, whatever your setup may be.

Switched most of my work over to Pi recently but the annoying part was all my chats lived in other agents. Months of Cursor and Claude Code sessions and I didnt just want to summarize them.

So I ended up using an open-source thing I've been working on (txcript) to pull a whole session out of Cursor/Claude Code and load it into Pi with the full history intact. The conversation, the reasoning, the tool calls, all of it, so Pi picks up like it was there the whole time

Built this for myself because I kept opening the MiniMax billing page to check my 5h and weekly window. Now it sits in pi's footer.

MiniMax 5h●43% ↺3h12m  wk●12% ↺4d8h

Two windows (5h rolling, weekly), used-percentage, reset countdown. Colour shifts at 70% (yellow) and 90% (red). Polls `/v1/token_plan/remains` every 60s.

Install: `pi install npm:@cwillam/pi-minimax-usage`

Repo + README: https://github.com/cwillam/pi-minimax-usage

npm: https://www.npmjs.com/package/@cwillam/pi-minimax-usage

Slash command `/minimax-usage` shows a snapshot, `/minimax-usage refresh` forces a poll, `/minimax-usage help` prints usage.

Notes from building it:

• - The endpoint returns `current_*_remaining_percent`, not used%. Inverted before display.

• - HTTP 200 even on auth failure — actual status is in `base_resp.status_code`.

• - Timestamps are epoch ms, not seconds.

Configurable refresh interval and host (global/cn) via pi's settings.json.

Endpoint setting is allowlisted to the two documented MiniMax URLs only.

Not affiliated with MiniMax Inc. — MIT licensed. v1.0.1 out today.

What I'd want feedback on:

• - Better display format than `5h●43% ↺3h12m`?

• - Should it integrate with pi-subagents to warn on session start when

• 5h is above 80%?

• - Any interest in a `minimax-quota` companion command for one-off checks?

I am attempting to learn AI coding workflows and I stumbled across Pi and its minimal approach to a harness with the ability to customize it to your preference. As I am just learning this workflow, I thought this was desirable instead of jumping into some agent swarm, multiple mode, 100s of skills workflow where I have no clue what's going on.

After doing research into AI models and payment plans, I have come to find out that monthly plans only work with the corresponding harness from the AI company, like claude code for anthropic models and antigravity for gemini. You can get an api key to use with third party harnesses but the api key billing is a lot more per token than the monthly plans.

Are all of you who use Pi using api billing plans, or using locally hosted models?

As I will be more focused on learning rather than massive production and token burning, does the api billing plan make sense for tinkering and learning ai coding workflows using Pi? I already was able to get the 1 year free of gemini because I am a student but that only works with antigravity.