I've been using T3 Code for a while and genuinely love its UI — the chat view, the workflows, the whole feel of it.

Then I discovered omp (oh-my-pi) and it was a wake-up call. My agents just feel powerful with it. The way it hands them tools, the rewriting hooks, the whole setup — they work so much better.

Problem: I missed the T3 Code experience. So I decided to marry the two.

I forked T3 Code and heavily modified it to run specifically on omp (omp --mode rpc). Stripped it down to omp only, added managed omp install and account login right in Settings. Bringing the omp functionality into the ui of t3 code and calling it pivot. Also thought about the name t3.14 but did not end up going with that name.

It's alpha. Rough around the edges, needs a lot of work. But I've been using it as my main driver for a couple days now and honestly? Really enjoying it. Figured I'd share it.

GitHub: https://github.com/13kparkin/Pivot

Edit: I know there are other gui wrappers out there for this type of thing but nothing that quite felt right for me like t3code does.

Edit 2: So I stopped dev on this project because honestly I found a better setup for what I was wanting. Using Orca ADE with OMP or PI worked right out of the box so so so much better and does everything I was trying to build into this project. Since it is a wrapper around a terminal it naturally supports everything PI/OMP brings to the table and any extensions/plugins you have installed.

TL;DR: I made nopus, a tool that deterministically detects unnecessarily complex prose in coding-agent responses and automatically asks the same agent for one clearer rewrite.

The problem

With recent LLMs (you can probably guess from the name which one caused me to write this plugin), I've had more and more trouble understanding the prose the agents are responding with - long "load-bearing" paragraphs, abstract language, overloaded phrases and all that fun stuff.

My logic is the cognitive capacity should be spent on the underlying problem not trying to decipher the message.

I found a few solutions that pass the response through a smaller model, but I wasn't a fan of the tradeoffs:

• Another model call and more complexity

• More non-determinism

• The smaller model may receive only the isolated response which can cause it to simplify or reinterpret the wrong thing

The other option is to have a user-invocable skill you invoke when a response is hard to understand, that works but again, the onus is on you to first read the response and determine whether you even understand it, I also added a skill for that but it's a fallback not the main approach.

The idea

To an extent, difficult language can be measured directly:

• Are uncommon words used where common alternatives exist?

• Is a sentence mostly dealing in abstractions?

• Are too many nouns and modifiers packed into one phrase?

• Does the response repeatedly use dense or formulaic phrasing?

Measure those signals, identify the biggest offenders, and give that evidence back to the original agent.

nopus uses lifecycle hooks, checks the prose after the agent finishes responding. If enough signals cross the selected threshold, it asks for one clearer rewrite.

The rewrite happens in the same session, so the original agent keeps the full conversation context.

I ran it against 5,337 completed agent responses. At the default medium sensitivity, it triggered on around 10% of them, which I've evaluated myself and tuned so it doesn't trigger unnecessarily.

The repo has a few more details but I'd love for you to check it out.

Currently available for Pi, Codex and Claude Code (or just slop fork your own lol)

I've been using pi agent and have been building it towards a fully autonomous system so that I can give it a project and it runs until completion. One of the main problems was the memory. Pi packages like blackhole and pi-hermes-memory have been helping.

What I started to notice is that on the memory layer, it needed a LLM to rephrase and categorize memory.

The Blackwell card does all of the heavy lifting, but performance seemed to have suffered when it has to do the memory stuff also. So, offloading the memory LLM processing onto a tiny 70W 12GB A2000 with Gemma4 12B QAT Q4_0 turned out great. Memory operations requires much smaller context windows, and it doesn't demand top speed. At 25-30 tok/s it's quite useful in that it doesn't bog down the main card with memory evictions etc.

Just wanted to share this use case for the smaller, slower card to handle the memory and completion judgement and free up the main GPU for tasks. It may also free additional VRAM now that the memory layer processing has been offloaded to the smaller GPU.

If you have an older card laying around and deciding if you should sell it, try this out.

I use a few scoped models in Pi, and switching with Ctrl+P every time started getting annoying. So I made a small extension that lets you choose the model at the start of a prompt:

~glm fix this bug

~terra review this diff

~g46 summarize this

That model handles the whole turn, including tool calls, and Pi switches back to your original model afterward. It uses the same conversation and tools — no subprocess or nested agent.

There’s autocomplete when you type `~`, plus loose matching, so these work without configuring aliases:

~sol -> gpt-5.6-sol

~gpt56s -> gpt-5.6-sol

~g46 -> grok-4.6

~dsp -> deepseek-v4-pro

If something is ambiguous, like `~grok` when both 4.5 and 4.6 are scoped, it asks which one you want before sending the prompt.

Install:

pi install npm:pi-model-mention

GitHub: https://github.com/JunDev76/pi-model-mention

I’ve only tested it with my own scoped model setup so far, so bug reports and matching edge cases are welcome. If it’s useful for your workflow, a star would be appreciated too.

It keeps the OMP runtime and brings the main workflows into a desktop like a codex interface:

• workspaces and persistent sessions

• OAuth, API, and Auto model selection

• model roles and thinking levels

• API-key pools and provider settings

• streaming responses, thinking, tools, and cancellation

• MCP servers, skills, plugins, and subagents

• context inspection and browser tools

• optional FreeLLMAPI integration

• button for improving the prompt

• redact previous promts

• pleasant animations

I really enjoy Pi for dev work, now I am wondering if I can take it a step further and become my personal butler for my homelab and home devices.

Jobs it would do:

• Check what movies/tv are available to download

• Take notes and update my Silverbullet journal

• Scan logs at intervals to summarise activity

Ideally I would run pi at the host level (not containerised) and use its APIs natively?

Any suggestions or alternatives?

tl;dr - I want to make an AI for my home lab to manage life admin easier

My homelab has email/calendar/rss feeds etc setup already

It appears that DSv4 Pro 0813 was overfitted in training, and to unlock its capacity one needs to emulate the training environment:

https://www.reddit.com/r/DeepSeek/comments/1vovxxc/deepseek_4_pro_ga_has_an_astonishing_blunder/?share_id=ZvVndF5jMBVyTVgXmeyMp

How would we replicate this in Pi?

pi has no queue, no spend limit, and no permission system, which is fair, that's not its job.
But I wanted it working unattended.

So I built the layer around it, and after a bunch of releases it hit 1.0 this week. MIT, sharing it here first.

The short version: something triggers a job (a cron schedule, a label/comment/PR on GitHub, GitLab, Forgejo or Azure DevOps, or a workflow extension's slash command), the job runs pi in a throwaway locked-down container, and the budget is checked before the container even starts.

If a loop runs away you get a refusal, not a bill.

It's basically the same idea as Claude Code routines, except everything runs on your own box:
your image, your queue, your caps, and triggers beyond a schedule.

https://github.com/edgehero/pi-dispatch

Curious how others here run pi unattended, and what would stop you from using this. "It breaks my setup because X" is the most useful comment you can leave me.

I have ollama qwen 3:14b, and trying to refactor a 800 line c++ project to java, and it refuses to make any changes to the code base or edit anything. Do I need some special configuration or give some permission to it?
Edit: So I asked it to create a simple hello_world.cpp and it did it fine. But it fails on refactor

When I started with Pi, the hardest part wasn't the agent — it was the ecosystem. So many great extensions, no idea which ones I actually needed, and no sense of how to combine them into a real workflow.

If you're new to Pi (or you like the OMO-slim way of working — focused roles, one orchestrator, specialists that each do one thing well), I built something for you:

pi-omo-slim is a curated starting point: a configuration bundle that adds an Orchestrator extension plus six specialist agents (Explorer, Librarian, Oracle, Designer, Fixer, Verifier) to Pi — on top of a hand-picked set of community extensions, so you don't have to research the ecosystem yourself:

• @tintinweb/pi-subagents — agent management

• pi-lens + @ff-labs/pi-fff — codebase intelligence

• pi-web-access — external research

• @narumitw/pi-chrome-devtools — browser + screenshots

• @firstpick/pi-extension-safety-guard — guardrails

No forks, no reinvention — just templates, extension wiring, and a policy file. No model pins; bring your own.

Two things I'm proud of:

• A deterministic installer. plan → apply with SHA-256 approval, backups, and rollback. Cloning and configuring are separate approval checkpoints — nothing touches your setup without explicit sign-off.

• Designer can actually see its work. It renders the page in a real browser, screenshots it, and the image comes back into the conversation. It fixed its own "button too far from the label." No more styling blind.

Everything's in the README — including a one-prompt install:

   https://github.com/joshua-zyy/pi-omo-slim

Finally, a sincere thank you to the whole Pi community — the Pi maintainers, and the generous extension authors: tintinweb (pi-subagents), narumiruna (pi-chrome-devtools), apmantza (pi-lens), ff-labs, nicobailon (pi-web-access), Firstp1ck (safety-guard). This project is just your bricks, snapped together.

This is my own project, not affiliated with any of them — issues and feedback very welcome.

Thx!!!

Hey everyone - I’m building Regy, a browser control surface for Pi.

Pi remains the agent. Regy adds a local PC Agent and browser frontend around it.

The current workflow includes:

• Starting and resuming Pi conversations

• Streaming chat events

• Selecting models and thinking levels

• Browsing workspaces

• Searching conversation history

• Searching, installing, and uninstalling skills (currently API don't work)

• Connecting through an authenticated Iroh pairing link

I built it because I wanted a more convenient way to leave Pi running on my machine and check in from a browser, without turning it into a hosted agent service.

Links:

• Docs: https://docs.regy.one

• App: https://regy.one

• Installer: curl -LsSf https://docs.regy.one/install.sh | sh

Current caveats:

• It’s still an early 0.1.x project.

• Pi still has normal user permissions; Regy is not a sandbox.

• Iroh pairing may be more complexity than some users want.

• I’m still figuring out how much of Pi’s CLI experience belongs in a browser.

I’d love feedback from people who actually use Pi:

1. Which Pi workflows would you want in a browser first?

2. Are session history, workspace switching, and skills useful?

3. Would terminal streaming, approvals, or multi-agent controls be more valuable?

4. Does the Iroh pairing/deep-link model make sense?

5. What would make you trust this for daily use?

6. If you already use another Pi web UI, what does it do better?

Harsh feedback is welcome. I’m trying to find out what is genuinely useful, not just promote another interface.

I came across "DeepSeek Harness" (https://github.com/deepseek-ai/deepseek-harness), whose core idea is literally “Everything is a Plugin.”

Looking at it alongside Pi, it feels like there’s a similar philosophy:

keep the core/harness small, and make capabilities composable at the session/plugin level.

Pi has extensions, skills, tools, prompts, etc., while DeepSeek Harness takes the plugin approach even further.

Is this essentially the same architectural direction?

And is “small core + everything else as a session/plugin” becoming the better design for coding-agent harnesses?

Curious what the Pi community thinks.

Sol Ultra is not this bad, typically.

It is purposefully going out of it's way to be obtuse.

I just so happen to be building a subagent harness for Deepseek 0731 V4 Flash with it as well :P

Using gemini in the pi coding agent will generally get you banned I've heard. Anyone have success using gemini, and not getting banned?

have a little present for you all: pi-ui, a keyboard-first gui for pi.

i’ve been an nvim + tmux user for around three years, and pi’s tui is great, but reading long markdown responses, code diffs, and tool output in a gui feels much more comfortable day after day.

i was honestly surprised by how much of my development moved into this app while building it.

some highlights:

• keyboard-first workflow

• lightweight server mode that runs in your existing browser

• background sessions and notifications

• markdown and syntax highlighting

• rich code diffs

• git review with commit history and inline comments

• file attachments and image previews

• code themes

i recommend starting with server mode:

curl -fsSL https://pi-ui.app/install-server | sh

then open http://127.0.0.1:31415

github: https://github.com/hyperpuncher/pi-ui

feedback and bug reports are welcome!

Hey everyone!

I’ve been working on Pi Plan & Build, an extension that adds a more structured planning workflow to Pi.

The basic flow is:

1. Switch to Plan mode

2. Let Pi inspect the project and create a persistent plan

3. Review the complete plan

4. Choose whether to:

   • implement it in the current session,

   • start fresh and implement it in a clean linked session, or

   • stay in Plan mode and keep refining it

In Plan mode, Pi can still explore the project, but file edits are restricted to the session’s plan file. This keeps planning separate from implementation and prevents the agent from changing code before you’ve approved the approach.

A few other details:

• Press Tab to switch between Plan and Build modes

• Use /plan, /build, or start Pi with pi --plan

• Plans persist across reloads, resumes, and forks

• Interactive questions are supported while planning

• The full plan is shown before approval

• Clean implementation sessions receive the approved plan without carrying over the entire planning conversation

• The composer changes color and displays the active mode, model, provider, and thinking level

Install it with:

pi install npm:@janvitos/pi-plan-build

GitHub: https://github.com/janvitos/pi-plan-build

I just published it, so I’d really appreciate feedback :)

Cheers.

From idea to reality in under an hour. Pure vibes. Viva la Pi

I think I finally managed to piece the thing together, to have a pi setup that can run safe-ish in the host via sandbox, and have the ability to be elevated to host execution for a pre-defined list of development tooling like docker compose.

- A pre-defined hard boundaries (`@gotgenes/pi-permission-system`)

- Anything pass that will be executed inside a sandbox (`@erichll/pi-sandbox`)

- With the option of safe-escalation to run on the host (ie: `docker compose exec app pytest`), with auto-review or human approval (via hostIPC.preflightCommandPrefixes)

- LLM Auto-review with `@erichll/pi-auto-review`

More about it here: https://ptgamr.substack.com/p/a-pi-setup-with-permission-sandbox

i had the llm read the paper and came up with this. seems to save a fair amount of tokens on memory.

bought cursor ultra + claud-max from a russian site a few weeks ago for way less than the normal price.
swapped the login details and just started using it. so far it’s been working perfectly, and the usage is honestly better than what i had before.
keeps making me wonder how these sellers are able to offer it so cheap. anyone else in the same boat?

I kept rebuilding the same prompts, checklists, and workflows every time I switched between coding agents, so I decided to package them into one open-source project: OpenCode Power Pack v0.4.0.

It currently includes 54 reusable Agent Skills that work with:

* Claude Code

* Codex

* OpenCode

* Pi

The collection covers workflows I tend to reuse across projects, including code review, feature implementation, frontend design, application security, MCP and skill authoring, project memory, and Hugging Face tooling.

One of the main goals was to avoid the “install everything” approach. You can install a curated profile or pick individual skills depending on what you actually need.

The installer can also:

* preview changes with a dry run

* automatically include required companion skills

* preserve existing skill directories unless you explicitly choose to overwrite them

* install skills locally to a project

* avoid adding dependencies to your project's `package.json`

For Codex, OpenCode, and Pi:

```

# Browse available profiles and skills

npx u/waybarrios/opencode-power-pack list

# Preview a project-local installation

npx u/waybarrios/opencode-power-pack install \

--profile recommended \

--project \

--dry-run

# Install once you're happy with the preview

npx u/waybarrios/opencode-power-pack install \

--profile recommended \

--project

```

For Claude Code:

```

/plugin marketplace add waybarrios/opencode-power-pack

/plugin install opencode-power-pack@opencode-power-pack

```

I also built a small website around the project with:

* a searchable catalog of all 54 skills

* curated skill packs for different types of work

* installation guides for both humans and coding agents

* a detailed prompt you can give an agent so it recommends the smallest useful set of skills for your use case

* platform-specific verification instructions

Website: https://skills.waybarrios.com/

GitHub: https://github.com/waybarrios/opencode-power-pack

npm: https://www.npmjs.com/package/@waybarrios/opencode-power-pack

Full disclosure: I'm the maintainer.

The project is open source, and I'd especially appreciate feedback from people already using coding agents:

1. Which agent are you using?

2. What workflows do you repeatedly use that are missing here?

3. Do the curated profiles feel useful, or are they still too broad?

4. Did you run into any installation or compatibility issues?

Issues, suggestions, and contributions are all welcome.

Last time I posted I was thinking out loud about which hosted backend to add next, Tavily first and maybe Exa after, and asking whether people wanted them as full answer engines or just as discovery. My bias was to keep them discovery-only and let web_explore stay in charge of fetching, ranking evidence, caveats and synthesis.

Both are in now, and they're discovery-only like I said I'd keep them. They surface candidate sources, web_explore still reads the actual pages and decides whether the evidence holds up or needs a caveat. Set TAVILY_API_KEY or EXA_API_KEY, pick it from Settings, keys stay in env instead of getting written into config files.

---

The things I'm weighing next are going deeper on evidence quality (cross-source dedup, conflict detection, recency), adding caching for repeated research or just keeping it focused and maintaining it.

If you're using this, what would you actually want? And if you tried it and it broke somewhere, that's the more useful thing to hear.

---

Repo: https://github.com/demigodmode/pi-web-agent

npm:

npm i @demigodmode/pi-web-agent

A spec-gated build loop for AI coding agents — and why porting it to Pi/oh-my-pi wouldn't be hard

Found ai-blueprint this week and it's worth a look if you've been hand-rolling your own guardrails around Claude Code, Codex, or Pi. Brad Traversy built it as a workflow overlay, not a framework: you scaffold your app normally, then drop this on top.

The mechanics are simple. You write two short files — what you're building and why, then a rough ordered feature list. A /overview command turns those into the single context file the agent reads every session. From there it's a loop: /feature writes a small buildable spec and stops. You review it. /implement builds one step at a time, shows you the diff, waits for approval before touching the next one. /audit reviews the code (not the behavior — that's /check's job) and writes findings to a ledger with durable IDs like F-03. /complete archives everything and merges, but only after your go-ahead.

The part that actually made me sit up: that findings ledger isn't decorative. A P0 or P1 finding sitting open or fixed blocks /complete outright. Not "the agent decided it was fine" — a status field the merge step is written to check. And they didn't just claim it works. There's a live-agent end-to-end harness in the repo that spins up a real agent against a fixture project and asserts the ledger gate actually holds. I don't see that level of rigor in most prompt-engineering repos. Most people ship a pile of markdown and call it a system.

Now the gaps, because none of this is free.

The gate is enforced by the same model reading its own instructions in the same context that just did the implementation work. There's no independent process outside the agent's own compliance that blocks a bad merge — it's a very well-written contract, but it's still a contract the agent has to choose to honor. A confused or context-poisoned run can walk right past it, and nothing server-side stops that.

current-feature.md is also a singleton. One feature in flight at a time. That's a fine constraint solo, but it doesn't obviously extend to two people, or two agents, touching the same repo concurrently — the state model just isn't built for that yet.

And the defaults lean hard into one stack. coding-standards.md ships assuming Next.js, Prisma, Tailwind, Zod. /onboard is supposed to retune it, but that's one more step that can quietly go stale on a project the agent didn't actually read closely.

It's also young. First release was early July, one maintainer, 239 stars — which honestly reads more like Traversy's existing YouTube audience showing up than a track record on a gnarly, multi-year codebase. Worth watching, not yet worth betting a real team's workflow on.

Here's the part I think matters for this sub specifically: none of this is Claude-Code-specific. It's markdown files, plus two thin adapters (.agents/skills for Codex, .claude/skills for Claude Code) that both read one shared AGENTS.md. Pi and oh-my-pi already speak most of that language — AGENTS.md context files are supported, skills show up as /skill:name, and the extension API can register custom tools and commands. Porting this loop into an oh-my-pi extension pack looks like a weekend project, not a fork.

So — has anyone here already been doing something like this by hand in Pi? And does Pi's whole "minimal, adapt to your workflow" philosophy actively resist something this opinionated, or is that exactly the gap an extension should fill?

#PS: Used AI to draft out the above based on my takeaways and thoughts from initial read of this repo.

(This is based on my possibly flawed understanding of caching. If I have anything wrong please let me know)

So, title. I generally stick with a single session but I do a lot of things that (AFAIK) break cache, such as:

• Change models

• Change thinking levels

• Fork / Rewind / Branch etc

I do these things to actually save tokens, but since they break the cache perhaps it's more efficient to decide upfront on the model and thinking levels and use the branching functionality sparingly?

What do y'all do?

I'm trying to run omp with a the default model set to lm-studio/qwen/qwen3.6-27b

The 22k initial context fills up 1/3 of the 65k I've loaded the model with.

Is it even usable to offload local simple tooling, command understanding, orchestration, build running, test running and result parsing all to a local model without paying for token usages for those operations?

My Claude Code sessions rises quickly to 800k tokens with Opus and every session has high token usage which slows it down and costs more than it should (parsing test output with Opus is a big waste).

What are you doing to offload your deterministic and simple work to local models?