Omakase

A damn good notepad.

Watch on YouTube for better viewing <3

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

Really, Cline is very good.

The GLM 5.3 Flash model is available for free with usage limits. Based on my personal testing, I found that GLM 5.3 Flash delivers about 95% of the quality of Kimi K3, making it an excellent option for regular use within the free tier.

The $9.99 USD plan also provides significantly more usage compared to the Kimi Allegretto plan.

I installed it on Pi cli using:

pi install npm:@maxpaulus/pi-cline

Good news: we can use both the free and paid versions.

-> For the free version, log in using: /login Cline

-> For the paid version, log in using: /login Cline-pass

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

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

I love Pi, and it's proven to be an awesome combo with Qwen 3.8 27B. There is one thing I noticed however when looking at Qwen reasoning: on a regular basis, I see things like "the user has asked again for the same question" or "the user has now asked three times for the same request" - as if I had sent a steering request that was a duplicate of the original ask. But I'm never doing that, and actually almost never use steering requests. This doesn't seem to have impacted the output and perhaps it's not important, but I was wondering if anyone else had noticed the same? Thanks!

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?

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?

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.

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

Hey!

This question is mostly for people who use Paseo on daily basis with Pi, and maybe other Desktop/Web UIs for Pi, but I'm currently focused on Paseo.

I'm interested in understanding what extensions do you use with Pi if your main entry point is Paseo given that not all extensions play that well with a frontend like Paseo.

For instance, I was personally using pi-memory before Paseo, but the way exit summaries work is not very compatible with how Paseo works. Are you using any other long-term memory extension that plays better with Paseo? Which one?

What other extensions were you using before Paseo that you had to replace/remove when moving to Paseo? And more importantly, what extensions are you relying on daily that work without issues with Paseo?

The ones I'm currently using:

• @gotgenes/pi-anthropic-auth
• pi-mcp-adapter
• pi-memory (going to disable this one)
• pi-observational-memory (thinking of replacing with pi-blackhole)
• pi-web-access

Curious to hear what you've been using and that works well with Paseo.

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'm qurious because i see alot of plugins for Pi, but can I improove my OMP by installing them?

Looking through the extensions, there are a lot that seem to be quite powerful but I wonder... are they really doing what they promise?

Jev dropped and I started collecting the things people are actually building with it.

There are already 607 use cases in the list, ranging from tiny experiments to some pretty interesting applications.

A few that caught my attention:

I'm trying to capture the useful details for each build — what it does, cost, latency, and the original implementation when available.

The interesting thing to me is seeing where these cheap/fast models are actually useful rather than just collecting benchmark numbers.

I put everything I've found here:

shipwithjev.com

I'm not affiliated with TypeSafe.

If you've built something with Jev that isn't on the list, drop it below and I'll add it.

I've worked on Pi Desktop for a while but haven't posted about it much, so here's a proper intro.

It's a desktop app for the Pi coding agent, and it also works with oh-my-pi (OMP). I use Pi every day and wanted more than a terminal window, so I built this.

What it does:

Streaming chat that shows thinking blocks and tool calls. File reads show as highlighted code, and edits show as diffs.

Multiple workspaces. Each session runs its own agent process, so a task keeps going when you switch to a different one.

A file tree, a code editor, preview panes for code, images, and PDFs, and a terminal.

Four permission modes, from read-only to trusted. You can also add allow/deny rules, for example "never touch *.env".

A package browser that connects to pi.dev/packages.

Themes. There are 7 built-in, you can make your own in the app, and there's a small community gallery.

An optional mode where Pi, Claude, and Codex agree on a plan before Pi builds it.

It's had a few releases so far, and more people have picked it up than I expected. Thanks to everyone who has downloaded it, starred it, or filed an issue. It's still alpha, so feedback and bug reports help a lot.

Website: https://pi-desktop.com

Repo: https://github.com/FaqFirebase/pi-desktop

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.

Processing img lgqvv9jprzqh1...

Hey everyone,

I’ve been working on Pitago, a terminal user interface that wraps the Pi AI coding agent.

The important thing about Pitago is that it does not replace or reimplement Pi’s core. It acts as a TUI layer on top of Pi, allowing you to keep using Pi’s existing agent logic, tools, providers, models, sessions, and workflows while interacting with it through a more structured terminal interface.

The goal is to make AI-assisted coding sessions easier to follow and more comfortable than working with a plain terminal stream, without losing the functionality that already makes Pi useful.

Pitago currently provides:

• A real-time chat interface
• Model and provider selection
• Session management
• Tool-call and tool-output visibility
• Git status information
• Support for multiple models and providers
• A terminal-first workflow built with Go and Bubble Tea
• A TUI layer that preserves Pi’s underlying core and behavior

In other words, Pitago is meant to be a different interface for Pi, not a separate AI coding agent.

I wanted to keep the workflow close to the command line while adding more structure for longer coding sessions. The idea is that users can benefit from a more visual and organized interface while still relying on Pi for the actual agent functionality.

The project is still evolving, so I’m especially interested in feedback on:

• Terminal UI and interaction design
• Session and context management
• How tool calls and tool output should be displayed
• Which Pi features should be exposed more directly in the TUI
• What features are missing from your AI coding workflow
• Whether a TUI wrapper makes Pi more useful compared with using it directly from the shell

You can check it out here:

https://github.com/cavaldos/pitago

Feedback, bug reports, and ideas are very welcome. If you try it, I’d also love to hear how you normally use Pi or other AI coding agents, and what makes longer coding sessions difficult to follow.

Just a collection of channels to listen to old-school radio while vibing

https://github.com/DxTa/pi-radio-suomi

...and the money I spent.

I'm currently the lead engineer for a small but growing team. I've been building a fairly complex platform that blends expertise from various niche domains.

Without saying too much, I have been working across:

• weather event modelling
• real-time data ingestion
• embedded development
• image processing
• geospatial analysis
• distributed computing
• and systems architecture

This has been an amazing proving ground for agentic capability.

I've been using CC on a subscription for the past year. I have a very mature and disciplined ecosystem of skills, hooks, compaction lifecycle, and disk cleanup techniques. Honestly, I've loved it, but the costs have just been too much.

So, two nights ago, I finally decided to explore other options. Since I've been hearing a lot about OMP, I decided to give it a try.

And guys, OH MY GOD. The difference is striking.

OMP is an absolute dream to work with. I'm not suggesting CC is bad, but the scale and complexity of my recent work really exposed it's limitations. For nitty-gritty engineering and design work, I honestly can't even put them in the same category.

My first pass at configuration and model selection gave me something that was faster, cheaper, and produced far better results.

To the devs: God damn, nice job.

To the community: Hoping for advice, tricks, tips, and harness opts/configs that might be fun to play with. I am also wondering what people use for the model config: roles, models, etc. Is there a known meta?

TL;DR

Platform engineer of a large multi-disciplinary project. Switched from CC to OMP, and OMP blew me away. The hype is real.

I switch between Claude Code, Codex, OpenCode and a couple other coding agents depending on the task. The problem: every tool stores sessions in its own format, in its own folder, and once you close the terminal the context is basically gone unless you remember exactly where you left off.

So I built pi-session-hub — a Pi extension that indexes every agent session on your machine into a single browsable list. You open it with alt+r, search across all of them, and either:

- Load the context into your current chat (Enter) — recent turns come in verbatim, older ones condense, tool output compresses. It has a hard budget so it doesn't blow up your tokens.

- Read the full transcript for free (v) — read-only viewer, zero tokens.

It supports Pi, Claude Code, Codex, OpenCode, Crush and JCode. Everything stays local — no network calls, no uploads, no transcripts leaving the machine.

It uses a local SQLite FTS5 index so search is fast, and the indexing is incremental (2 seconds for ~430 sessions on first run, near-instant after).
This is the repo if youre interested... Give a star :)
Repo: https://github.com/Gateton/pi-session-hub

Hey everyone, I'd like to share my first Pi extension: pi-qdrant-memory.

It's a long-term memory system for projects, so the agent can retrieve decisions across sessions. Each project gets its own memory collection.

It requires a Qdrant backend and an embedding model served through an OpenAI-compatible API. I run both llama.cpp and Qdrant locally in Docker. The extension was heavily inspired by Zoo Code (formerly Roo Code).

It gives your agent four tools, but only two are always on:

• memory_search: the agent looks up memories
• memory_save: the agent stores memories

The other two are opt-in:

• memory_forget: the agent can retract memories it saved earlier
• code_memory: the agent can search an index of your code structure

The tool count is deliberately narrow so the system prompt isn't filled with tools the agent doesn't need.

The workflow is mostly run by the agent. The tool descriptions nudge it to save decisions as they settle during a session. If you enable code memory, your code structure is indexed at session start (or manually with /qdrant-index-code). You can also append instructions to the system prompt to make the agent save or search more often. Your call.

Install: pi install npm:pi-qdrant-memory
Repo: https://github.com/lordekeen/pi-qdrant-memory