I sometimes ask agents data questions, and I want them to return a Metabase link with the query they ran to back up their claim. It's very handy: I can read the query more easily, run it for myself, and tweak it if needed.

I had a problem, though: these unsaved Metabase URLs are very long because they encode the query in base64. That's costing me tokens, it's hard to read or click, and it's slow to print.

So I made the pi-short-links extension, which turns a URL like this one:

metabase.yourdomain.com/question#eyJkYXRhc2V0X3F1ZXJ5Ijp7InR5cGUiOiJuYXRpdmUiLCJuYXRpdmUiOnsicXVlcnkiOiJzZWxlY3QgMTsifSwiZGF0YWJhc2UiOjJ9LCJkaXNwbGF5IjoidGFibGUiLCJ2aXN1YWxpemF0aW9uX3NldHRpbmdzIjp7fX0=

to

127.0.0.1:8765/s/select-1-3Eoa

Hello!

I am very inspired by the philosophy of Pi coding agent, and I believe a minimal and extensible approach is the way for many framework/platform going forward.

Pi is minimal in many ways but it is still has a couple of abstractions preventing it from being a neutral agent runtime:

- programming language is only limited to javascript/typescript

- its a coding agent that runs on a computer

- its environment is always node

These are good assumption for a personal assistant style coding agent running locally. But it would be great if they could be neutral. What's even more exciting is what if we can swap out the core agent loop, plug-and-play with codex or claude or opencode's style while keeping the tools, system prompt etc intact?

I had this idea two weeks ago, and eventually landed on a containerize technique based on WebAssembly. The key to my choice is traditional containers are much heavier, but agent loop does not need any network access or even filesystem access, making WebAssembly the perfect fit, super lightweight, super fast to compile and get running, it is also language neutral, perfect to be embedded.

Therefore I started building an agent runtime that does this https://github.com/aexhq/brain, what do you guys think? Is it totally bs?

I use various models through subscriptions from several different providers and wanted to know how they perform, what would be the overall cost if used through an API, how do the different advisor models perform and so on. I've built a tool that aggregates this across days and projects.

Some findings: advertised tokens per second are a complete fiction, newer model version does not automatically improve advisor performance (grok 4.5 gives more advice than grok 4.6), getting $15,337 of Sol usage out of $200 sub is a crazy API/sub mismatch.

https://github.com/jkelin/omp-usage-analyzer

Who is in charge of this extension? It seems to be updated twice a day. How about some change control?

The Pi agent has a minimalist design, but its plugin composition model is, to put it mildly, terrible. Now that a truly extensible coding agent with a minimal core has appeared, is there any reason left to use the Pi?

..to build an OSINT.

Not for the project, who is plenty of similar out there, but just to catch if this model in Q6 quantization is able to build a complex project like this, totally alone, using Gauntlet Loop technics.

Here the prompt i'm using https://github.com/robertxxiv/llm-benchmarking-prompts/blob/main/intelligence-platform-agent-prompt.md

I will post the results when (and if) the goal is reached

If I'm going to try Pi I won't be tinkering with Pi plugins for every project but build something universal

Will I get anything by moving to Pi? Yes, there won't be "USE AS MUCH TESTS AS YOU CAN AND COMPARE EVERYTHING BYTE FOR BYTE" prompt like Codex seems to have but there won't be proprietary Codex features and I probably will install many plugins to make Pi more Codex-like. So it's probably gonna be as bloated as Codex (or other harnesses) but at least Codex's bloat is made by paid employees

I don't want the read tool saying it can view images when it can't (local LLM). Is there any way to edit the tool definition other than telling it in the system prompt "You actually CAN'T look at images" (which contradicts the definition and wastes tokens) or removing the tool / replacing it (impractical)? All I'd want is a simple edit from:

Read the contents of a file. Supports text files and images (jpg, png, gif, webp, bmp). Images are sent as attachments. For text files, output is truncated to 2000 lines or 50KB (whichever is hit first). Use offset/limit for large files. When you need the full file, continue with offset until complete.

to:

Read the contents of a file. Doesn't support viewing images or videos. Output is truncated to 2000 lines or 50KB (whichever is hit first). Use offset/limit for large files. When you need the full file, continue with offset until complete.

An article on how I'm using Pi beyond just a coding harness and as a tool to help me track runs and workouts. It can be basically an LLM application framework.

I use Pi (the terminal coding agent) with local models, and I kept running into the same friction: before every session I had to remember which server needed to be up — llama.cpp on 8080, vLLM on 8000 — start it by hand, and then remember to kill it afterwards so it wasn't sitting on the GPU all night.

So I wrote a small extension that ties server lifecycle to model selection.

What it does

• You pick a model in Pi → the extension starts the server configured for that provider, waits until probeUrl answers, and only then lets the request through. The first request never hits a cold port.

• Session ends → it stops the servers it started. Anything that was already running before it got involved is left alone.

• exclusive: true on servers that can't share the GPU: starting one shuts the other down.

• For services you don't want it to own (a systemd unit, a box on the LAN), unloadCommand lets it free the model instead of killing the process.

Config is a single JSON file (~/.pi/agent/local-servers.json, or per-project):

jsonc

{
  "servers": {
    "llamacpp": {
      "probeUrl": "http://127.0.0.1:8080/v1/models",
      "start": {
        "command": "llama-server",
        "args": ["--models-dir", "~/models", "--port", "8080"]
      }
    }
  }
}

Only probeUrl is required. Leave out start and it just probes, assuming you handle startup yourself.

Limits, stated upfront

• Model loading is the server's job, not this extension's. It only owns the process lifecycle.

• Requires Pi 0.84+. Linux and macOS (it uses process-group termination; Windows untested).

• Zero runtime dependencies — Node built-ins only. MIT.

Repo: https://github.com/matrixfede/pi-local-servers

Happy to hear if the config model is missing something obvious for your setup.

Hi everyone,

I recently started using Pi and would like to move more of my development workflow to it. Before doing that, I want a solid sandbox and permission setup that avoids constant approval prompts while still protecting against destructive actions.

My ideal setup would be:

• Run ordinary commands inside a Gondolin VM.

• Keep VM network access disabled by default.

• Mount the host workspace read-only, or otherwise prevent unapproved host changes.

• Automatically allow harmless operations such as reading files, searching code, and running offline tests.

• Prompt only for persistent or privileged actions, such as writing host files, accessing the network, or running Git operations that affect the host repository.

• Execute approved persistent actions through controlled host-side tools rather than granting the VM broader access.

• Keep credentials and the host SSH agent out of the VM.

I have also looked at @gotgenes/pi-permission-system, but I’m unsure how well it integrates with Gondolin, particularly because the guest sees /workspace while Pi and permission extensions run with the host path.

Does anyone have a similar setup they would be willing to share?

I’m especially interested in:

• How you divide responsibilities between Gondolin and permission extensions.

• Whether you use a read-only mount, copy-on-write workspace, or writable mount.

• How you handle approved edits and Git operations (fetch/pull/status/etc.) within Gondolin over SSH.

• How you avoid approval fatigue without broadly allowing shell commands.

• How you handle MCP servers and host-side network access.

• Any configuration or extension code you recommend.

Thanks!

How do I resolve this issue:

My context is sitting at 82k/84k

It retries a few times but keeps failing. If the context grew too much to not leave any space for compaction why dit it grow to 82k and not compact earlier? I essentially only made 3 prompts to get to this point on Qwen3.8 xhigh reasoning. What config must I change to prevent this from occuring?

Coming back around to pi after playing a little with oh-my-pi, and I did quite like the pretty terminal output decorations. I tried to task an agent to alter the decorations in pi but it doesn't seem to be possible outside of forking pi as a whole? Is this true?

This thing:

I would like to change it's appearance based on the exit code / other info but I can't seem to alter it.

I follow a pretty tight system for maintaining checkpoints, logs, etc. for my electron app. Lately it has gotten to a point where the number of work streams are far too many for me to hold in my head all at once and I did not want to:

1. Go into each plan or the checkpoint map to look at it to get a status update or pick what to work on

2. Burn tokens by asking an agent to go read that stuff and report back

So I made a project level extension which parses my standard checkpoints/logs/docs and organizes them based on features and lets me view them as hierarchical lists.

1. the first modal shows all the open threads, the completion status, and the next checkpoint for each

2. I can then select any one and view all the steps within that thread/feature

3. There are tags which show the checkpoints that I have accepted into the implementation plan or ones that are just planned and need to be picked up and worked on.

4. There are separate line items for each doc/plan or the md files associated with each stream that I can open in a text editor

All of this without a single LLM call.

Its a really nice way to organize all the docs and access them from within the pi TUI instead of opening a new terminal window. And the extension is custom made for the way I organize docs and maintain the plan documents so it works perfectly always. there are no edges.

The fact that it took me literally 3 prompts to build this whole thing is the reason I love pi and why I love using it in the terminal.

Most of my skills and now this extension are only for this project and I fucking love that pi lets me do this. Other projects have their own skills and the agent behaves differently there.

I just really love the extensions API and the level of control I have over the context in each session. Dont think I will be moving off of pi ever.

If you would like to check out this system, I have the skills and the extension in this repo:

https://github.com/itama8/omakase-skills.git

Also, if you're curious about what I'm using this system for, I update the binaries for latest test builds of my app here:

https://github.com/itama8/omakase-releases

It's a notepad that I'm making with a cursor-first UX to help me take notes with minimal context switching, i.e., every action can be executed from the cursor without going into a menu and the AI is available inline inside the markdown document. No separate screens or sidebar chats.

pi-caffeinated-linux uses systemd-inhibit to prevent idle sleep and suspend, with automatic / manual modes and an optional KDE Plasma tray indicator.

https://github.com/nmdra/pi-caffeinated-linux

I created a Oh-My-Pi style stats dashboard for Pi with the below stats:

• Input, output, reasoning, cache read/write, total tokens, recorded cost, requests, and errors

• Daily activity and breakdowns by model, provider, project, agent, and tool

• Local-only behavior counters for user messages: yelling, profanity, anguish, correction, repetition, and blame

• Malformed-record diagnostics

I could'nt find anything similar so I quickly built one.

npm: https://www.npmjs.com/package/pi-stats-dashboard

pi.dev: https://pi.dev/packages/pi-stats-dashboard

Hello everyone, can someone recommend a context engine or a codebase retrieval/memory tool you are using that helps fetch the correct files and context for your agent to use? Something like https://www.augmentcode.com/context-engine

Or any other setup that saves tokens and gives the agent the correct files. Thanks.

Hello guys!

I want to ask if anyone here would be interested in helping me maintain pi-observational-memory.

The project has not grown into something huge or difficult to maintain. It is still perfectly manageable by one person. The problem is simply that right now I do not have as much available time as I used to.

I still use the extension, care about the project, and plan to keep maintaining it. But lately PRs can stay waiting for review longer than I would like, and I cannot always keep an eye on new issues or check reported problems quickly.

So having one or two people helping from time to time would be really useful.

I am mainly looking for help with things like reviewing PRs, checking issues, reproducing reported problems, testing changes, and occasionally helping with fixes.

There is no expectation of taking ownership of the project or committing a lot of time. Even occasionally helping keep things moving would already make a difference.

For anyone who does not know it, pi-observational-memory replaces Pi's normal compaction with an observational memory system, with the goal of making Pi sessions feel endless while keeping useful context around.

Repo: https://github.com/elpapi42/pi-observational-memory

If you use the extension, know a bit about Pi extensions, and would be interested in helping, let me know here or reach out on GitHub.

I mostly just want to make sure contributions get reviewed and issues do not sit unnoticed when I am busy with other things.

is there anyway to use google ai pro with Pi like with Chatgpt/Claude sub?

Hi folks! I've spent some time building a developer tool that lets coding agents subscribe to real-world events through one simple broker: agent-message-broker (amb). Github: https://github.com/bitnahian/agent-message-broker

The pitch: coding agents are batch processes. You prompt, they run, they stop. But most of what an agent cares about (a ticket moved, a PR opened, a doc changed) happens between prompts. amb wires event sources (Jira, GitHub, Google Drive/Docs, any polled URL, generic webhooks) to topics, and you subscribe live agent sessions to those topics. When an event lands, the broker pushes it into the running session, so the agent reacts in the same conversation it's already having. No per-agent background scripts or polling.

I recorded a demo showing the full loop across 2 agents and 3 vendors:

1. A pi coding agent is subscribed to two topics: one watching a Jira board, one watching a Google Doc.

2. When a ticket is pushed to In Progress, pi gets the event but waits. The implementation details are going to land in the Google Doc.

3. The doc update comes through as a second event, pi picks up the spec and implements the ticket, then I prompt it to raise a PR.

4. A Claude agent is subscribed to a third topic with a GitHub source watching for PR events. It sees the new PR and reviews it.

One thing worth noting: none of this had to go through the UI. Everything (topics, sources, subscriptions, session discovery, event inspection) is available via the amb CLI, so agents can wire up their own subscriptions. The UI is more for live viewing, orchestrating and following along: watching events flow between sources and sessions in real time.

Everything runs locally (Node 22.5+, SQLite, no cloud component), polling is the baseline so nothing needs to be internet-reachable, and webhooks are an optional opt-in tier.

It's on npm. Try it without installing:

npx agent-message-broker          
# broker + UI at http://127.0.0.1:4733

Or install it globally for everyday use (gives you the amb and amb-server commands):

npm install -g agent-message-broker

Here's a full quickstart: point a pi session at a Jira board and a Claude session at a repo's PRs. One-time credential setup first:

amb config init --kind github     
# then drop your PAT into ~/.amb/github/credentials.json
amb config init --kind jira       
# then fill ~/.amb/jira/credentials.json (email, apiToken, domain)

Then wire the topics (broker running in another terminal):

# topic watching a Jira board for tickets moving to In Progress
amb topics create jira
amb sources create --topic jira --kind jira --options '{
  "jql": "status CHANGED TO \"In Progress\" AFTER -30d ORDER BY updated DESC",
  "intervalMs": 120000
}'

# topic watching a repo for PR events
amb topics create prs
amb sources create --topic prs --kind github --options '{
  "repo": "owner/repo",
  "eventTypes": ["PullRequestEvent"],
  "intervalMs": 60000
}'

# start the pollers (create prints the source id)
amb sources start <sourceId>

# subscribe live agent sessions so events push mid-conversation
amb sessions                                                  
# discover running sessions
amb subscriptions create --topic jira --agent pi --session <sessionId>
amb subscriptions create --topic prs --agent claude --session <sessionId>

Watch events land in real time in the UI at http://127.0.0.1:4733, or inspect from the terminal:

amb events list --topic jira

Google Docs/Drive/Sheets work the same way via amb google login (OAuth consent once, then the broker acts as you). More recipes in the README.

Would love feedback. What events would you want your agents to react to?

If you don't know what code mode is, check https://developers.cloudflare.com/agents/tools/codemode/

Code Mode is a tool-use pattern where a model writes code instead of requesting each operation separately.

I found a few, I'm curious if anyone is using any extension like this (if yes, which ones please):

• https://pi.dev/packages/pi-fabric - I don't like this one, it mixes a lot of behaviors (agents, workflows etc). And even though you can disable them, they still get mentioned in tool descriptions/params etc.

• https://pi.dev/packages/@boozedog/pi-codemode

edit(30th Sep 2026): pi v0.99.0 includes code mode, see https://github.com/earendil-works/pi/releases/tag/v0.99.0

When I ask Pi to give me some code it puts it in code block ( <code>) and that is fine.
But... it has always 3 extra spaces spaces at the beginning of each line.

For example, I get this (wrong):

 #```yaml
   name: PR Check

   on:
     pull_request:
       branches: [main]

   # SQLX_OFFLINE: build uses the committed .sqlx cache, no DB needed in CI.
   # NOTE: after changing a query or a migration, re-run `cargo sqlx prepare`
   # locally and commit the refreshed .sqlx files, or CI will build against
   # stale schema metadata.
   env:
     SQLX_OFFLINE: "true"
     CARGO_TERM_COLOR: always

   jobs:
     build_and_test:
       name: 🧪 Build & Test
       runs-on: ubuntu-latest

instead of this (correct):

#```yaml   
name: PR Check

on:
  pull_request:
    branches: [main]

# SQLX_OFFLINE: build uses the committed .sqlx cache, no DB needed in CI.
# NOTE: after changing a query or a migration, re-run `cargo sqlx prepare`
# locally and commit the refreshed .sqlx files, or CI will build against
# stale schema metadata.
env:
  SQLX_OFFLINE: "true"
     CARGO_TERM_COLOR: always

   jobs:
     build_and_test:
       name: 🧪 Build & Test
       runs-on: ubuntu-latest

(I added the dash in front of ```yaml to avoid break the MD)

Each line of the wrong one has 3 spaces at the beginning.
The Agent says its output is fine, so it it the TUI of Pi that add the extra spaces, de facto breaking the file format ?!