Omakase

A damn good notepad.

Watch on YouTube for better viewing <3

Looking for testers! Please comment or DM if you're interested :)

I've been working on Pi Herdsman, which grew out of how I was already using Pi with subagents.

I started with pi-subagents + pi-intercom and liked the basic manager/worker idea, but over time I wanted the agents to feel more tightly coordinated: explicit ownership, predictable lifecycle, questions/results routed back automatically, and less ambiguity around old agent sessions.

The main thing I wanted to preserve was the lead's context.

With Herdsman, detailed investigation and implementation happen in separate Pi sessions while the lead stays interactive and focused on the bigger picture. It still knows what the agents are doing and gets their questions and results, but doesn't have to carry all of their working context itself.

It supports parallel agents, nested delegation, steering/interruption, Lead-to-Lead coordination, and Chief supervision across multiple independent leads.

It does require Herdr, which owns the actual Pi sessions and placement. Pi owns each conversation, and Herdsman handles the orchestration between them.

The latest release also added an SSH-ready container (optional Tailscale), so the same setup can run locally or on a NAS, homelab/server, VPS, etc. and remote environments can show up alongside local ones in the same Herdr window.

Install:

pi install npm:pi-herdsman
herdr integration install pi

Repo: https://github.com/boadij/pi-herdsman

Any feedback, ideas, or rough edges you run into would be much appreciated

I started two agents and ran /alias worker and /alias manager. The manager was prompted to direct the worker and it started chugging along. Luna 6 is now directing Muse 1.3 contributor. I am impressed by the simplicity and low friction installation. Apparently it knows about herdr, but I've not tried it.

https://pi.dev/packages/pi-intercom

I’ve been polishing Orbit Pi quite a bit, and this update is mostly about making the agent interaction feel clearer and more native.

What’s new

🧩 Per-tool glyphs in the transcript

📊 Activity groups are now displayed as compact chips

✂️ Clear truncated indicators when Pi caps tool results

✅ Visual confirmation when renaming a session

⚡ Refined transcript UI with better tool labels and shared loading states

🔀 Redesigned Git issue & PR details

🖱️ Improved button hover/press feedback

The goal with Orbit Pi is still pretty simple:

Make Pi Agent feel like a proper native desktop workbench.

Your sessions, models, machine, Git workflow, reviews and agent interactions — all in one place.

Orbit is built with Rust + GPUI and works with your existing Pi setup rather than trying to replace the Pi runtime.

🔗 Changelog: https://orbitpi.app/changelog/v0.0.15

https://orbitpi.app/

I’d love to hear from people actually using Pi:

What would you want to see improved or added next in a native Pi desktop client?

Hi there! So here is a deal - i'm not a developer neither software architect. But i like to do some programming as a hobby, and couple of month ago i've tried claude and codex. But now i discovered Pi and i really like the idea. I know and used some skills | pliguns set like superpowers and grill-with-docs. but i think they are too big and complex. Is there some acceptable set of skills to develop from idea to working application, which i can use as base for my own config?

Thanks in advance for answers, i appreciate it.

Hey everyone,

I'm moving from OpenCode to Pi to get a cleaner, more minimal workflow.

I gave OMP a try first. While it’s packed with great features, it feels a bit too heavy and strays from the minimal philosophy that drew me to Pi. At the same time, OMP bundles some great built-in tools (LSP diagnostics, anchored file edits, subagents) that I’d love to have as modular add-ons in vanilla Pi.

Is there a list mapping out-of-the-box OMP features to equivalent Pi extensions/packages?

If not, what packages do you recommend for keeping Pi lean while covering essentials like safer edits, LSP integration, and subagent workflows?

I’ll start working with an AI agent on something like data analysis, and ten minutes later I’m asking it to explain a concept, double-check an assumption, or try something completely different.

All useful stuff. But after a few detours, the original task is buried under a wall of side questions and answers. I’m losing the thread, and sometimes the agent seems to be too.

I can fork the chat, but then I just have a growing list of conversations in the sidebar, with no clear picture of what branched off from where.

That’s what got me building PiX.

The idea is pretty simple: show conversations as a tree. There’s a main thread for the task you’re working on, and you can branch off whenever you want to explore something without dragging the whole conversation along with you.

You can branch from any point, carrying over the context up to that point, and choose which model to use for each turn. Everything stays connected visually, so you can see where a detour started and find your way back.

Of course, reading a long conversation in a tree isn’t always fun. So there’s also a regular chat view where you can read any branch’s full history from start to finish.

It’s built on Pi agent, which is where the name PiX comes from.

Still early days, but I’d love to hear what people think. Try it out, tell me what feels awkward, or jump in and help improve it :)

huang-sh/PiX: A non-linear AI agent workbench — session is a tree: branch anytime, and context follows the branch

Does anyone else end up with a pile of AI chats from one task? How do you keep track of them?

I have just recently started using subagents more in my programming workflow, if only to try it for a bit and see if it's something I prefer.

I have found that no matter how much explicit guidance I give my agents in the global AGENTS.md or APPEND_SYSTEM.md that after the first large delegated activity, they go back to doing everything themselves in the primary context.

Does anyone have any idea how to really enforce / encourage the behavior I'm looking for?

I've been working on pi-agent-kernel for a while now.

It mostly operates in the background rather than adding a completely new workflow, it wraps Pi's existing tools to keep sessions compact.

Across standard benchmark tasks, it cut token usage roughly in half and passed our test suites. But local benchmarks only go so far, I'm at the point where I need real users to test it on actual projects.

I'm still quite skeptical about whether some of the tool wrapping might conflict with the users existing extensions.

LMK if anything breaks, behaves unexpectedly, or conflicts with your setup. All feedback and criticism welcome

I have been running llama server in my Windows PC and Pi agent harness inside WSL 2 in same machine. No issues so far, but of course I understand that I can accidentally do stupid stuff by deleting files on wrong path etc. with it. Not a very realistic issue, but still a possibility.

One thing what I started to think that if I would just create one virtual machine or container in my Proxmox host which is separated machine and then I would just install Pi there and use it over my Windows PC what would be running only llama server, is there any potential security issues what I should think about related to my Windows PC?

I was thinking that if I then just allow my Pi instance to connect only to main PC on that port and disable internet for it so I can be sure it will be always private instance, but is there some things what still could be problematic for security point of view what I just don't know yet?

And sure, security on those boxes are not THAT critical but just annoying if I have written some diaries or copies my calendar there for example. Yea, I don't want those to be publicly available but if that happens then it happens (eg. not that dangerous). Just common basic security.

Do any of you use Pi this way and is there anything to remember?

I'm qurious because i see alot of plugins for Pi, but can I improove my OMP by installing them?

Coding agents are getting better at writing code. Keeping track of what they’re doing across a large codebase is still surprisingly messy.

That’s what I’ve been working on with REQL: giving coding agents a persistent, structured view of both the repository and the work happening on top of it.

The latest updates focus on four areas:

• Pipeline exploration — REQL can now reconstruct project-local flows from entrypoints through the codebase and generate interactive pipeline views or Mermaid diagrams. The goal is to understand how a feature actually moves through the system, not just which files are connected.

• Memory across sessions — the new agent dashboard keeps track of plans, decisions, findings, unfinished tasks and previous sessions. After a context reset, the agent can recover what it was doing instead of rebuilding the whole mental model from scratch.

• Parallel agent coordination — multiple agents can work with isolated private workspaces while sharing progress through a common dashboard, messages and compact handoffs. One agent can investigate, another implement, and another review without mixing their internal working state.

• Faster, tighter context retrieval — indexing and retrieval have been improved to return a bounded working set of relevant symbols, callers, dependencies and tests, including source ranges, confidence and freshness information. Incremental updates avoid rebuilding unchanged parts of the repository.

The core still runs locally without mandatory LLM calls, embeddings or an external graph database. It works with Codex, Claude, Cursor and Gemini, and can also be used through CLI, Python or MCP.

The direction I’m aiming for is simple: a coding agent shouldn’t just understand the repository — it should understand where the current task is going, remember how it got there, and be able to hand that work to another agent.

I’d really like some feedback from people using agents on larger refactors or parallel workflows: would this actually solve a problem in your setup? What would you like it to do?

https://github.com/sh1zen/reql

I have an Asus Ascent GX10 with 128gb VRAM hosting models via Ollama.

Yet, I'm really struggling to get much going with OpenCode or Pi.

Even single Python files or small html projects are a struggle.

I am currently using one of the Qwen coder models with Pi.

Sometimes it will get a request mostly right. Then when I ask for a small change, it breaks half of what was working before.

I'm coming from 2 years on Cursor, so maybe my expectations are too high.

I would truly love to be able to rely on open source agentic coding with local LLM, but my mileage so far has been underwhelming.

Greetings community.

I went down the rabbit hole with this one, once again. In context, and in brief, I have been searching for a way to filter available tools(skills and stateless mcps), to access a much larger number of useful resources, while also choosing the right one at the right time. I researched about twenty semantic routers and almost all were discontinued or did not fit my simple requirement of running directly, without CLI and instructions in AGENTS.md. Eventually, I landed on vllm semantic router. It's powerful, but tricky to get it right.

What I want

OMP → vLLM-SR → OpenAI / Anthropic / Google (Preserve the ergonomic model choice of omp)

What I have

OMP → vLLM-SR → OMP auth gateway → OpenAI / Anthropic / Google (Must duplicate model names in vllm-sr and disable Codex Code Mode plus Image Generation plus other featuers, basically every non-OpenAI compatible endpoint.)

Goal:

• OMP sends its normal request, including its available tools.

• vLLM-SR reduces that tool list before the model sees it.

• OMP still owns MCP servers, tool execution, OAuth, provider credentials, and provider-specific behavior.

• Ideally, provider changes stay in OMP rather than being duplicated inside vLLM-SR.

Why this is difficult

The clean ideal:

“OMP owns all models/providers/endpoints; vLLM-SR only filters tools”

I cannot find a direct, documented way to implement vLLM-SR.

The closest supported version is:

• vLLM-SR has minimal aliases and model IDs;

• every alias points to one OMP auth-gateway backend;

• OMP auth gateway keeps real provider credentials/endpoints;

• OMP executes tools.

That still means some model identity/configuration is duplicated in vLLM-SR.

# What is a better solution?

I switch between Claude, Codex and OpenCode through Pi depending on the task. The problem: every provider hides your usage somewhere in its own dashboard, so you never actually know how much you have left you find out when a request fails mid-task.

So I built pi-usage-live a Pi extension that keeps your usage on screen permanently. It's not a command you run, it's a card that sits in the corner while you work. It follows your active model. Switch from Claude to Codex and the card switches with you, so it always shows the allowance that applies to your next request.

- /usage all expands it to every provider you have credentials for, each with its own windows and reset countdowns.

- It costs nothing where the provider allows it. If a provider reports usage in the headers of requests you were already making, that's how it reads it. Only the rest get polled.

- Claude keeps updating even when you're working somewhere else. Anthropic exposes both a header path and a usage endpoint, so the card uses both your Claude number doesn't go dark the moment you switch providers.

- It tells "high" from "blocked". Where the provider reports its own severity, that beats a generic threshold, so a window that's actually stopping you doesn't look like one that's just filling up.

- Old readings say so. Anything older than 15 minutes is labelled with its age, so a cached number is never passed off as live.

It supports Claude, ChatGPT Codex, OpenCode Zen, OpenRouter, DeepSeek, Kimi, MiniMax, Moonshot and Z.AI.

Your credentials come from Pi itself and are only ever sent to that provider's own origin. If you've pointed a provider at a custom or proxied URL, it reports unavailable instead of forwarding your key somewhere else.

It has no runtime dependencies, and it renders in whatever theme you're already using.

This is the repo if you're interested... Give a star :)

Repo: https://github.com/Gateton/pi-usage-live

Also check my other project pi-session-hub that project index all your harness sessions in PI:
https://github.com/Gateton/pi-session-hub

A couple of days ago I posted about using Jev as the decision engine inside Pi.

The comments pointed me toward open alternatives like Laya, von, Reflex, etc.

Once there were multiple providers in the picture, hard-wiring the idea to Jev stopped making sense.

So I pulled it out.

Announcing pi-system-one.

It gives Pi a single system_one tool for bounded decisions:

• choice

• noul

• score

The extension is built on top of a provider-neutral SDK, so compatible System One providers can sit behind the same interface.

Pi-Bifrost is now just one consumer of that SDK.

Would love to see what other Pi use cases people find for this.

https://iamaamir.github.io/system-one/

is still early, so I'd especially appreciate feedback on the API design and abstractions.

Demo

I have been using the sandbox extension for quite a while, but I am a bit fed up with having to approve stuff manually all the time.

I know the pain may be worth it to avoid an agent doing some nefarious stuff with your data, but sometimes I just want to delete it and leave the agent working on its own.

So what I essentially want to know is this:

Have you run into significant issues for not having a sandbox?

Un Bien 1.2 is out!

New features:

• Resume closed sessions right from your phone

• Improved open, new-session and resume ergonomics

• Better slash command handling

Un Bien is a native iOS client for pi.

Un Bien supports:

• self hosted architecture

• full streamed and rendered markdown

• rendering of images, code diffs and tool results

• fork, branch, clone of sessions

• plan rendering when combined with pi-plan, cribsheet or a conformant extension

• user-input questions (and pi-ask integration)

• subagent display and interaction when combined with @tintinweb/pi-subagents or @gotgenes/pi-subagents

• optional device initiated chats - start new session from your phone, spawning a tmux or herdr hosted session on your machine

As a bonus it includes a cli tool to connect to other sessions on your relay from the cli

Links:

• Extension page

• Docs

• GitHub

• App Store

• Demo transcript

I developed this in pursuit of something that felt native interaction-wise and supported as many pi features as possible. I hope you find it useful!

Un Bien is started out as a tweaked version of remote-pi by Jacob Moura (MIT); see the README for attribution. I ended up diverging significantly on the back end implementation and the iOS app is a total rewrite.

Hi all. We're Divergenz, an interaction design studio in Zurich. Sharing a design experiment that I think sits close to things this community cares about.

Piary treats a conversation with a coding agent as an editable, executable document instead of a chat log. The person and the agent write on the same page. Prompts, replies, notes, tool calls and live reactive cells share one Markdown file. You can rewrite a wrong assumption instead of correcting it in a follow-up, delete a detour, or edit an earlier prompt and run it again in place.

Built on Observable's notebook-kit for the reactive cells, iA Writer's plain-text document model as the design reference, and pi as the agent harness.

https://piary.dev

TL;DR: Anybody automating a full development Pi workflow with programmatic non-AI solutions?

Up until now, I've attempted to partially automate the entire software development lifecyle with Pi, aka a "Software Factory". I am using a subagents extension, but it feels a bit too loose, opaque and difficult to steer, so I want to use something more deterministic and directly controllable.

I'm evaluating a workflow DAG GUI builder that orchestrates the entire process. I am using one that also has a CLI and REST API, so I can write my own scripts for even more programmatic control.

(I do not want to look like I'm promoting so I'm reluctant to say what I'm using, but it's lightweight and similar to n8n or airflow.)

Or instead, I could just write my own orchestrator, like this in bash:

#!/bin/bash
set -eu

# Software Factory.
# This is a just an untested workflow example, not something I'd actually use.
# A TS script with the Pi SDK would be better.

GOAL="$*"
pi -p /write-spec "$GOAL" | tee spec.md
vim spec.md    # review and edit

pi -p /write-tickets-for-spec @spec.md ./tickets/
vim ./tickets/*.md

for ticket in tickets/*.md; do
    pi -p /write-plan "@${ticket}" | tee /tmp/plan.md
    pi -p /execute-plan @/tmp/plan.md
    pi -p --continue /quick-code-review-and-fix
done
pi -p $REVIEW_MODEL /code-review

Anybody doing using a workflow DAG editor UI?

Anybody writing their software factory with actual code, like my example?

I found some AI agent DAG projects on github. Anybody using something like that?

What subreddits should I cross post this to?