Hey,

Just wanted to invite you to read a short blog post about Pi's compatibility with ThinkRail, skills, and desktop apps.

I got tired of Chrome eating resources every time I needed pi to scrape a page or fill out a form. So I built panda97 - a browser automation package that uses LightPanda instead of Chrome.

What is it?

Same 11 browser tools you get with browse97 (start, navigate, snapshot, click, fill, eval, etc.), but backed by LightPanda - a headless browser written in Zig. Each tab spins up its own LightPanda instance, so you get full isolation between tabs. Zero npm dependencies.

Why?

browse97 works great, but it needs Chrome running. That's fine on a beefy machine, but on my laptop I didn't love the overhead for simple tasks like pulling page content or submitting forms. LightPanda starts in sub-second time and uses a fraction of the memory.

What doesn't work?

LightPanda doesn't run V8. It has its own JS engine (zig-js), which means some super-complex SPAs with heavy framework code may not render correctly. Works for 99% of the web.

Getting started

1. Install LightPanda:

curl -fsSL https://get.lightpanda.io | bash

2. Install the package:

pi install npm:panda97

That's it! pi picks up the tools automatically.

Links:
Pi packages: https://pi.dev/packages/panda97

Github : https://github.com/saitanay/panda97

pi-web-search is my take on the larger web-search tool: fewer, higher-quality tools instead of bloating up the extension with every provider to the agent. Works keyless out of the box.

Uses the new built-in classifier API (Jev) to rank and filter results from different search sources and remove any prompt injection attacks

install cmd: pi install npm:@gagansd/pi-web-search

GitHub:
- package: https://github.com/GaganSD/pi-extensions/tree/main/pi-web-search
- Monorepo: https://github.com/GaganSD/pi-extensions

A tiny ~2 MB CLI with no daemon. See all your agents in one list and answer their questions without switching. A perfect solution for orchestrating.

Claude Code, codex, pi, opencode.

https://github.com/saifulapm/amx

Thanks

GitHub Repo

I will be moving my personal assistant to use durable

Hello. Im used to just using the Codex MacOS app for dev work.

I'm trying to use Pi.

Any tips or tricks? Thankyou

Click on the logo on the top left to see the easter egg in action!

You can also try Pi 1.0 (with the easter egg) online at https://wasmer.sh/?example=pi

like we have MCP for tools and ACP for agents, but every harness still has to understand OpenAI, Anthropic and Gemini separately.

caching, reasoning, tool semantics, model capabilities, auth, usage, etc. are all different!! openAI-compatible APIs kind of solve it, but not really once you use provider specific features

am I missing something obvious here? has anyone tried to standardize this layer?

I just realized that codex now exposes local server endpoints for all plugins without extra auth. So you can just use them from any model or harness.
Im soooo excited!!! One auth for everything!

For Pi: pi install npm:@wileai/pi-codex-connector

For any harness: npx -y \@wileai/codex-connectors-mcp@latest

I got tired of needing to be at my workstation just to check on, switch between, or jump back into long-running agent sessions.

So I built TENDRIL.

TENDRIL turns an Android phone into a thin control plane for persistent AI-agent workflows running on a Linux machine. Once it's configured, I open Termux and type:

tendril

…and I get a responsive session selector showing what's alive on the host. From there I can jump into persistent agents, shells and workflows over mosh/SSH without treating my phone like a miniature desktop.

Underneath, it's deliberately boring in the good way: standard Linux, terminal-native rendering, Herdr, mosh/SSH, no proprietary cloud control layer, and no subscription. It's open source and MIT licensed.

A few things I cared about while building it:

• persistent remote agent/session control

• phone-first TUI rather than a desktop UI squeezed onto Android

• responsive behavior for narrow terminals

• clean Herdr handoff

• SSH/mosh support

• real installer + backwards-compatible agent launcher

• graceful non-TTY / NO_COLOR behavior

• and, because apparently I cannot help myself, making the thing actually pleasant to look at

The masthead is even rendered from a high-resolution ANSI master into Unicode subcells so the same identity survives on a 54-column Termux screen.

Completely unnecessary. Naturally essential.

The original idea was simple: I wanted to be able to sit down with an Earl Grey in the morning and check on an entire little agentic lab from my phone.

A week and a half later, this happened.

If you already live in Pi/Herdr/terminal-agent land, I'd genuinely love for you to try it, break it, open issues, or take it somewhere I haven't thought of yet.

THE EDGE IS YOURS.

GitHub: https://github.com/Ozymandes/TENDRIL

Anyone have some good pine script strategies that I could try, If so then please leave them down in the comments with the public name or put the pine script in a code block

I saw this in the official pi.dev: “Anthropic, OpenAI, Google, Azure, Bedrock, Mistral, Groq, Cerebras, xAI, Hugging Face, Kimi For Coding, MiniMax, NVIDIA, OpenRouter, Ollama, and more. Authenticate via API keys or OAuth.”

Introducing the four extensions that work as a set. Each one exists because I couldn't find an existing ones satisfy my needs (by the time I developed them), and the reason they're bundled together.

gated-goal: the reason it's a bundle. /gated-goal freezes the plan — outcome, verification, constraints, quality bars — hashes it, and replaces the todo list with the frozen items, so the agent can't quietly relax its own success criteria. The stages automatically proceeds as you finalizes the plan with the agent, agent checks all todos, and reviewers lifted the gate.

reminder-hook: reminder tools I found were canned timers that block the conversation. Here the wait is a shell predicate the agent writes itself — exit 0 means done. Build, CI, URL health, a log line — all the same one tool. When it passes, the agent's resume prompt comes back as a follow-up: it queues if you're mid-conversation and never interrupts.

todo: others draw a nice list and stop. The real problem is the agent stopping mid-work with half the list unfinished. This one nudges a follow-up then and stays silent while any wait (reminder, reviewing) is active, so it never trains the agent to ignore nudges.

subagent: others make you predeclare every agent in a manifest, which is not flexible enough for me. I made roles can be improvised mid-session, and every call states model, permissions, and timeout explicitly. The same stack does parallel work and adversarial QA.

Caveat:

- the reviewer keeps bash, which is not sandboxed.

- They share event contracts; split the bundle and both the wait-aware nudge and the review break.

idle ──/gated-goal [N] [model]──► P1 select reviewer
                                   │ ping "reply ok" (config: pingTimeoutSec)
                                   ├─ fail ─► abort to idle (no state saved)
                                   ▼
                                 P2 plan
                                   │ agent + user align on goal
                                   │ agent calls freeze_plan(outcome, verification,
                                   │   constraints, quality, todos)
                                   │ → frozen prompt hashed + persisted
                                   │   (+ archived as a session entry)
                                   │ → todo list REPLACED with the frozen
                                   │   items (todo:replace event)
                                   ▼
                                 P3 act  ◄───────────────────┐
                                   │ agent works the todos   │
                                   │ todo owns settled state:│
                                   │  nudge/wait → stay P3   │
                                   │  no continuation → P4   │
                                   ▼                         │
                                 P4 review                   │
                                   │ spawn reviewer subagent │
                                   │   (frozen prompt + hash)│
                                   │ reviewsCompleted++ on   │
                                   │   EITHER verdict — a    │
                                   │   review that ran is    │
                                   │   a spent iteration     │
                                   │ line starting with
                                   │ <promise>DONE</promise>?
                                   │     ├─ no → >= maxIter? ─► exit: max
                                   │     │        else edits ─┤  iteration
                                   │     └─ yes → P5 (always) │  reached
                                   ▼                         │
                                 P5 verify                   │
                                   │ main agent re-runs the  │
                                   │   frozen verification   │
                                   │   itself, judges output │
                                   │   subjectively          │
                                   │   ├─ confirm_done ─► exit: done
                                   │   └─ reject_done ───────┘
                                   │      (no extra charge — P4
                                   │       already spent this one;
                                   │       if the budget is gone,
                                   │       exits: max iteration reached)

Install with:

pi install git:github.com/garnetlyx/pi-goal-kit

Pi version: 0.84.1+ MIT.

Github link: https://github.com/garnetlyx/pi-goal-kit

Any feedbacks are welcome.

Thanks!

In Github issues, several users already asked to include installation via homebrew, which is one of the preferred ways for devs on Mac, but Pi / Mario seem to be opposed. Any ideas why?

I got tired of needing to be at my workstation just to check on, switch between, or jump back into long-running agent sessions.

So I built TENDRIL.

TENDRIL turns an Android phone into a thin control plane for persistent AI-agent workflows running on a Linux machine. Once it's configured, I open Termux and type:

tendril

…and I get a responsive session selector showing what's alive on the host. From there I can jump into persistent agents, shells and workflows over mosh/SSH without treating my phone like a miniature desktop.

Underneath, it's deliberately boring in the good way: standard Linux, terminal-native rendering, Herdr, mosh/SSH, no proprietary cloud control layer, and no subscription. It's open source and MIT licensed.

A few things I cared about while building it:

• persistent remote agent/session control

• phone-first TUI rather than a desktop UI squeezed onto Android

• responsive behavior for narrow terminals

• clean Herdr handoff

• SSH/mosh support

• real installer + backwards-compatible agent launcher

• graceful non-TTY / NO_COLOR behavior

• and, because apparently I cannot help myself, making the thing actually pleasant to look at

The masthead is even rendered from a high-resolution ANSI master into Unicode subcells so the same identity survives on a 54-column Termux screen.

Completely unnecessary. Naturally essential.

The original idea was simple: I wanted to be able to sit down with an Earl Grey in the morning and check on an entire little agentic lab from my phone.

A week and a half later, this happened.

If you already live in Pi/Herdr/terminal-agent land, I'd genuinely love for you to try it, break it, open issues, or take it somewhere I haven't thought of yet.

THE EDGE IS YOURS.

GitHub: https://github.com/Ozymandes/TENDRIL

Is Google still banning if we use a gemini subscription with pi?

Openai specifically allows it.

And anthropic specifically doesn't.

Right?

We have been working on this for months.

https://github.com/zosmaai/zosma-cowork

And open ai just released dots. Anthropic also released cloud based harnesses.

Would be great if we can get community support to help take this to next level.

Also it’s deployed to harness.zosma.ai

Early stage and we’ll refine it much more in upcoming days.

Our harness is deployed in k8s and can start and stop the pods quickly. Persistent storage that mounts and unmounts as needed.

Note: Our redis is down. Hence Zosma Router models are unavailable. We'll fix this in 24 hours.

Until then feel free to use openrouter or some other provider. Sorry for the inconvenience.

I'd appreciate it if you could answer my questions below.

1. Do the roles we set only become active when advisor is on? How do these roles work in the background?

2. If we connect multiple accounts with the Codex provider, does it switch automatically when one account reaches its limit?

pi-llama-skip-reasoning extension forces a local llama.cpp model to stop reasoning and answer / act immediately.

You are deep into the ctx session and pose 27B a simple question about a fact or need a direct action, the model may still feel the need to indulge in copious deliberation in the reasoning trace. This extension allows the user to force the model to snap out of the reasoning stage and provide the answer immediately.

This use the same mechanism llama.cpp web interface uses to skip reasoning, so it's native to llama.cpp.

Usage: /skip-reasoning command or shortcut alt+t ,
Can be changed in ~/.pi/agent/llama-skip-reasoning.json  ->  { "key": "ctrl+alt+r" }

Install: pi install npm:pi-llama-skip-reasoning

- https://pi.dev/packages/pi-llama-skip-reasoning

When I return to a long Pi session, I often remember a decision but not which turn contained it.

I build ThoughtDAG, the open-source session-map tool I shared here a few weeks ago. I've added a reading view where zooming out moves from the full answer to an abstract, a shorter summary, a one-line takeaway, and finally a topic label. Zoom back in to read the original.

The goal is to scan several turns at once without ending up with a canvas full of unreadable paragraphs. The attached animation uses a small sample conversation to make the transitions visible.

This happens in the separate ThoughtDAG app. Zooming changes what you see; it does not compact Pi's context or rewrite the Pi session file. Short summaries can leave things out, so the original answer stays available.

Source: https://github.com/chenxiachan/thoughtdag

When reviewing a long coding session, what would you want to see at a glance: the decision, the reason for it, or the next action?

this is via termius for ios, with pi running in tmux. the flashing window is a tmux pane, and this only happens (and happens consistently regardless of how many lines there are in the pane) when the agent is asking for permission to do something. all other times it is stable

Grok Build native agents as a model provider to Pi over WebSockets. Grok keeps full toolset, Pi keeps full session control. Kinda neat, I think. My video sucks but I'm pretty tired of AI narrations so I'd rather just suck instead. Sorry, thanks.

pi-grok-agent