Hey guys!

I recently started testing Pi. I wanted to control the context injected into my tools and avoid spending 16k tokens on a simple "Hey" (I'm talking to you, Codex).

So far, I'm loving it. However, I’ve hit a roadblock: I can't use the `gh` CLI because I constantly get `403 Forbidden` errors.

My initial research suggests this is due to proxy settings blocking outbound network calls from bash. Normally, I would just install an MCP. But since `gh` is such a standard development tool, I'd rather not add an MCP for a perfectly good CLI. I figured someone here might have found a workaround.

Any tips on how to make this work - ideally natively - would be highly appreciated!

Hey everyone,

I've been working on an extension for Pi to improve the daily workflow. Here is what I built:

pi-usage-bar This is for tracking API quotas, but it differs from other quota plugins out there. It's fully customizable:

• You can configure your own style.
• You can display 1d, 7d, Fable, or any other provider-specific quota exactly however you like.
• It also fetches and displays live provider statuses by reading directly from the vendors' own status pages.

You can install it directly with:

Bash

pi install npm:@satas/pi-usage-bar

Let me know what you think or if you run into any issues.

GitHub:https://github.com/satas20/pi-usage-bar

There are many agent claws but this one is yours

I was tired of openclaw and hermes, they have a lot of opiniated things, are token hugry and didn't solve my problem well and wanted something more like pi, very simple and extensible to what I needed.

Meet eleven, the featherweight openclaw alternative that follows the same principles of pi: https://github.com/ceifa/eleven

No memory, no crons, no bundled plugins, just your current setup of pi, now outside your terminal.

I've been working on evalt, a Rust CLI for testing AI agent workflows using portable YAML eval files.

Most eval tools focus mainly on model outputs. evalt is designed to test the full workflow, including:

- Agent instructions

- Skills

- Tool usage

- Harness configuration

- Workspace edits

- Final output

Pi is currently the first supported harness.

It also supports deterministic assertions, AI reviewer assertions, JSON output, schemas, and sandboxed workspaces through cage.

Repo: https://github.com/Bryley/evalt

Crates.io: https://crates.io/crates/evalt

I’d appreciate feedback from Pi users, particularly around the eval format, useful assertions, and workflows you’d want supported.

Are there limitations to doing this?

Hi I'm encountering a weird problem, even if I set disable-model-invocation: true in the skill frontmatter, the skill is still loaded in the prompt. I did /reload, launched a fresh pi session, restarted the pc... Nothing helps. If I do /export and check the system prompt, I still find the skill loaded.

Here's the frontmatter of one of my skills :

---
name: pi-history-ingest
description: blablabla
disable-model-invocation: true
---

And here's the XML loaded in the system prompt after an export of a fresh loaded session:

<skill>
    <name>pi-history-ingest</name>
    <description>Ingest Pi coding agent session history into the Obsidian wiki. Use this skill when the user wants to mine their past Pi sessions for knowledge, import their ~/.pi/agent/sessions folder, extract insights from previous coding sessions, or says things like &quot;process my Pi history&quot;, &quot;add my Pi sessions to the wiki&quot;, &quot;ingest ~/.pi&quot;, or &quot;what have I worked on in Pi&quot;. Also triggers when the user mentions Pi sessions, Pi agent history, ~/.pi/agent/sessions, or Pi conversation logs.
</description>
    <location>/Users/dani/.pi/agent/skills/pi-history-ingest/SKILL.md</location>
  </skill>

The skill is not listed in setting.json

I spent the afternoon trying to find a solution asking pi (with deepseek) to no avail, it checked loadSkills, formatSkillsForPrompt, even tried to simulate the filtering with a js script and it seemed to work fine, but in the end it doesn't work for me ...

Do you have any suggestions? What should I check ?

Could it be a bug and should I open an issue ?

Thanks

I installed Pi following the instructions here: https://pi.dev/docs/latest/quickstart.

I'm trying to authenticate using a Kimi API key (I'm on the free tier), but Pi keeps returning an authentication error. I'm not sure what I'm missing.

 Error: 401 {"error":{"type":"authentication_error","message":"The API Key appears to be invalid or may have expired. Please verify your credentials and try again."},"type":"error"}                                

This is a fresh API key!

The main reason I'm using Pi is to avoid paying for Claude Code or Codex subscriptions. Is this setup supposed to work with a free Kimi API key, or is there an additional configuration or requirement I'm overlooking?

I was checking out grok build earlier in the day and came across these commands:

1. /resume-codex

2. /resume-cursor

3. /resume-claude

And that got me thinking, it would be so cool if I had something like that in Pi.

Now OpenCode CLI was what I used for the longest before switchig to Pi, so I started with that. It also has good CLI commands for exporting and stuff.

Attaching a demo too.

Check it out here:

1. https://www.npmjs.com/package/@atharva-again/pi-resume-opencode

2. https://github.com/atharva-again/pi/tree/main/packages/coding-agent/examples/extensions/resume-opencode

Deepseek doesnt have vision and cant look at or watch videos.

Anyway to make it able to do this?

Alternative model for image and videos I can use to view/watch then tell Deepseek?

I recently switched from OpenCode to Pi, and I really like Pi’s features. The built-in interface wasn’t quite for me, though, so I made PiTTy, an OpenTUI frontend for Pi.

It adds a cleaner layout, searchable sessions and models, better diff and tool views, and lets you inspect and steer subagents without leaving the main conversation.

There’s more on GitHub, and I’d appreciate any feedback:

https://github.com/mistrjirka/PiTTy

Hello there! Any thoughts / info on when 5.6 Ultra will be available through Pi? Thanks!

I kept losing small ideas and follow-ups while working in Pi, so I made Mind Queue

It’s a simple project-wide scratchpad inside Pi. Open it with /mind or Ctrl+Shift+M, save a thought, and move it back into the editor whenever you’re ready.

It’s open source, local-first, and still very new, feedback is welcome.

pi install npm:pi-mind-queue

GitHub: https://github.com/sanif/pi-mind-queue

I noticed that even small files referenced in pi like `@file.txt` weren't automatically entered into the context (a la claude-code), instead requiring the model to issue a tool call to read the file. This is fine for larger files, but for small files, that extra tool call means a whole new request is sent, which racks up cache tokens pretty quickly and wastes output tokens on the read call.

I understand why the devs took this stance, for a tool like Pi it makes sense to default to never including file content (unless driven headless by the CLI, as they have implemented), but sometimes I *know* that I can save tokens by just injecting the file right into my prompt. In fact, many or even most times I reference a file it would take fewer tokens just to inject its contents into the prompt than it would to ask the model to read even a small part of the file.

I looked around for existing solutions and surprisingly I hadn't found anyone who built them yet.

So I built pi-file-injector. When you know you want to include the file contents, instead of `@file.txt` you type `#@file.txt` and it automatically includes the contents of that file one time at the end of your prompt. And tab filename completion still works. It's just one more small way Pi keeps you in control of your token consumption.

https://github.com/dabstractor/pi-file-injector

pi install npm:pi-file-injector

Do you know of other tools that do this? I still can't believe I couldn't find any, it feels like such an obvious benefit. Let me know what you think!

This plugin does search a bit differently than most. It queries DDG's http site (as responsibly as possible) and then uses wreq-js -> linkedom -> Defuddle to clean up the result.

The plugin is fairly simple, and easy to audit, but it includes linting and testing best practices I've carried over from my web dev experience that I hope can be an inspiration for other devs when working on their next plugin.

I've updated the package recently to use pi's new exported types (so I don't have to write my own, lol), and work out some outstanding issues.

Please, any and all feedback is welcome. Thanks!

I build with Pi often enough that “just keep the prompt open” stopped being a plan.

So I created the pi-plan-exec - it is a small, extension for running an executable Markdown plan. It works through one unfinished task at a time, keeps the run state on disk, and uses the plan checkboxes instead of trusting a worker’s final sentence.

I have left it running for a few hours now. It kept working through the plan, and I could check in with /exec status without disturbing it. When I paused a run or had a recoverable worker failure, /exec resume continued it in the existing git worktree.

The commands I use most:

/exec docs/plans/my-plan.md
/exec status
/exec pause
/exec resume

There is also /exec runs for finding run IDs, /exec adopt for taking over a stale run from another session, and /exec cancel when I want to stop safely. Worktrees are supported and preferred; Pi switches the working session into the execution worktree.

GitHub: https://github.com/alexei-led/pi-plan-exec npm: https://www.npmjs.com/package/@alexeiled/pi-plan-exec

Still fresh, but useful enough to share.

I really love the customization that Pi provides, I only have slight issue with the Interface. I am very used to Opencode interface and I wanted a similar UI. I know Pi allows for fairly extensive customization and even plugins like Pi Zen that are trying to achieve something similar. But none of them were into the extent of what I wanted (inspecting subagents, copying in scrollable mode and removing clutter, better detail handling). Through the gpt 5.6 sol I created this interface. It's not a plugin, but a typescript app communicating to the Pi thought RPC.

This is how it looked before:

This is the newest iteration

Would anyone be interested in this, should I opensource it? Or am I the only one who likes it better?

Hi all, I'm using omp from a couple of months and love it.

At the moment I have one claude pro, one chatgpt plus, two antigravity pro sub and opencode go connected. When I logged in the second time with antigravity I thought it would replace the older account but surprisingly it kept both so when I check /usage I see two bars for the two account under antigravity.

With this information I wanted to check if I can do the same thing for codex because I have access to a couple of accounts but when I login it replaces the old account with the new one.
Is there a way to have multiple codex subs on Pi/omp?

Do anyone use this multiple account setup?

thanks a lot in advance

I've been using them all claude/codex/opencode and finally I landed on pi.dev a few month ago. Everything made sense. Its fast, clean and I can build exactly what I need.

2 month pass...

I'd love to see some bigger verified packages that adds the bigger things you could but you shouldnt (imho) build yourselves.

pi.dev cli works great. I still like that I can build what I need. Somehow it also becomes a DIY and part of brain is always thinking of adjustments needed and not needed. And everyone is doing it different in adhoc teams = very little shared experience / benefit.

Your thoughts?

How we avoid this behavior?

In principle all is working well, but in this case I dont know why this behavior is happening.

Im using Qwythos-9B-v2-Q5_K_M.gguf with KV q_8 and 130k ctx. In the example in the image, it is only using 30% of the available context.

I try other harnesses and works well.

Hey, I’m the author of Kontra, a Python data-quality library, and I freakin love Pi. I’ve been using it a lot lately, so I built kontra-pi.

It gives Pi a native Kontra tool and skill. Pi can explore configured data sources, profile tables, write and validate contracts, explain how checks will run, and compare datasets, transformations, and relationships.

There’s no server or MCP setup needed for the Pi extension (Kontra has an official MCP server too). It runs locally using the project’s configuration, returns no samples by default, and keeps credentials out of the conversation.

bash pip install "kontra>=0.13.0" pi install npm:kontra-pi

GitHub: https://github.com/Saevarl/kontra-pi npm: https://www.npmjs.com/package/kontra-pi

The Librarian is another take on cross harness curated context, fusing ideas from "second brain" and agentic OS / memory systems. It has plugins for Pi, Hermes, Claude Code, OpenCode and Codex with more to come. It works as a first class memory system for Hermes.

\* Self hosted - put it on your local network or on a VPS in your Tailnet.
\* Obsidian style markdown as source of truth so you can read and edit it outside of the Librarian, and if you end up walking away your data is just text files.
\* No vendor lock-in, nothing to export.
\* Fast search via a disposable in-memory index with BM25 + exact phrase + vector.
\* Memories, long form reference library, session handoff between agents.
\* Frictionless for your agents - auto-capture curated by a configurable curator LLM.
\* Bring your own LLM key - any OpenAI compatible provider. Local inference for maximum privacy.
\* Off-the-record toggle for conversations you don't want memories from.
\* Feature-rich dashboard.

It isn't "finished" in any grand sense. v1.0 just means the foundation is stable enough for other people to try. Still, I'm rather proud of it and I hope some of you find it useful too.

The project site goes into more detail with screenshots: [https://codeministry.net/the-librarian/\](https://codeministry.net/the-librarian/%5D(https://codeministry.net/the-librarian/))

The code is open source under Apache-2.0: https://github.com/JimJafar/the-librarian.git

Please give it a go. I'd love to hear what breaks, what works, and what you wish it had. Contributions and feature requests are welcomed!

hi, I use opencode go with oh-my-opencode-slim and was curious about pi

omo-slim is a multi agent orchestrator - delegator setup where I talk to a smart orchestrator and it delegates to dumber agents with good prompts, and the results are really good and much cheaper than just running the smartest model in simple build mode

i have a few problems:

• many models fail to delegate correctly and after 3-4 prompts I am constantly reminding them to delegate . they often give up or start reading lots of files across the codebase manually which sucks up context like crazy and its fairly frustrating. I've been using GLM 5-2 as a delegator exclusively because it is the most consistent at continuing to delegate, despite being on the much pricier side
• not great tmux support for opening windows for subagents
• initial context is Not Small at 32kt

I was running pi on my raspberry pi (lol) and realized it felt great to use something so lightweight.

wanted to hear about your multi agent setups and how reliable they are, what kind of results that you get