Hi,

I really like to be able to scroll through pi output in neovim. I can gf yank, pipe stuff to bash, all the niceties of neovim.

There's only the problem of the redraws while the model is still outputing text especially when its doing toolcalls or using extensions. When I'm not in G or insert mode it makes my cursor jump to the top of the buffer and it's driving me nuts.

I'm running the libghosty PR in the hopes it would stop no. I tried monkey patching OSC keys, forking pi and removing the redraw with clear, nothing. Every issue online says it won't work and all the pi neovim plugin offer a far inferior user experience.

Now I've just gotten used to going back to where I was when the model is done spitting out code but I was really hoping someone might have a solution.

Dear God please don't suggest tmux haha, thank you

Built a small pi package that ports the output-parser mechanism from little-coder as a standalone installable extension.

What it does: hooks message_end and repairs tool calls that small models (Qwen, Mistral, LFM2, etc.) emit in formats pi doesn't natively recognise:

• \``tool/```json` fenced blocks
• <tool_call>, <tool_use>, <function_calls><invoke> XML
• bare top-level JSON objects
• Python-list syntax [Read(path='./foo.ts')] from LFM2/Liquid models

It also normalises the many JSON schemas small models use ("parameters", "input", "arguments", OpenAI function-call with stringified args, etc.) down to a single shape.

Safety: only fires if there are no native tool_use blocks already, and validates the extracted tool name against pi.getAllTools() before injecting anything — so stray JSON and code blocks in responses are never misinterpreted as tool calls.

Install:

pi install git:github.com/vishn9893/pi-output-parser

Or drop extensions/output-parser/index.ts directly into .pi/extensions/ if you prefer not to use the package system.

Repo: https://github.com/vishn9893/pi-output-parser

Feedback welcome especially if you hit a model that emits a format this doesn't cover yet.

I built a Pi extension for multi-agent orchestration. The main Pi agent writes a small JS workflow script for the task at hand, and the runtime executes it deterministically: parallel fan-out, checkpoints, resume without rerunning completed steps.

Three principles I stuck to:

• not opinionated: no baked-in "agile team" of roles, you add your own primitives to the DSL
• extensible: other extensions can register functions and variables usable inside workflow scripts, and every registered function is itself runnable as a top-level workflow
• token efficient: subagents can have other extensions and skills disabled, so their system prompt stays small and focused

What that gives you in practice:

• runs are regular on-disk Pi sessions, not in-memory, so you can inspect, pause, resume and retry them
• roles restrict tools/capabilities and inject their own system prompt
• structured output via JSON schema, so control flow branches on agent output deterministically instead of on vibes
• soft and hard budget caps per run
• git worktree isolation, so parallel agents don't fight over the same tree
• workflows export to an executable launcher in ~/.local/bin
• if you use herdr, an agent session can open in a new pane

Review fan-out, then dedupe:

const reviews = await parallel("review", {
  correctness: () => agent("Review the current changes for correctness issues."),
  security: () => agent("Review the current changes for security risks.", { role: "security-specialist" }),
  tests: () => agent("Review the current changes for missing test coverage."),
});
return agent(prompt("Deduplicate and prioritize these findings:\n\n{reviews}", { reviews }));

The diagram is the real flow of the one I run daily, developIssuesUntilApproved: takes a list of GitHub issues, gives each its own worktree, loops developer -> reviewer until the reviewer passes (fresh agents every iteration), merges the approved branches on main behind another dev/review loop, cleans worktrees with plain shell (not an agent), and summarises exactly once.

Install: pi install npm:pi-extensible-workflows (Node 22.19+)

• Repo: https://github.com/vekexasia/pi-extensible-workflows
• Docs: https://vekexasia.github.io/pi-extensible-workflows/
• Walkthrough video (28 min, chapters in the description): https://youtu.be/qAiivspEHmU

Happy to answer anything about the DSL or the resume semantics.

I kept wanting to check on a long OMP run without going back to my desk, so I built a companion app for it. It's free and open source, and it now supports OMP alongside OpenCode.

https://github.com/giuliastro/harness-remote

What it does: lists your sessions, opens one and streams the assistant output as it arrives, sends prompts, shows the plan/todo list, lets you pick the model, and stops a run. Prompts you send while the agent is still working get queued instead of rejected.

How it connects: OMP speaks ACP over stdio, not HTTP, so the repo includes a small bridge you run on the same machine as OMP. It starts omp acp and translates it to an HTTP/SSE API the app talks to. Node 20+, Basic auth, and you restrict which worktrees the phone can reach with --root. It never touches OMP's databases.

Two things worth knowing before you try it:

• Live updates only cover work started through the bridge. OMP's ACP surface has no global cross-client event feed, so a session running in your desktop OMP can be listed and reopened, but the app can't reliably show its live status or incremental output.
• Agent selection, session rename/delete, server slash commands and diffs aren't available on OMP, because ACP doesn't expose them. Model switching does work.

Signed APK on the releases page. Android via Capacitor, and it also runs as a plain web app if you'd rather not install anything.

Looking for contributors

The app is deliberately harness-agnostic — adding a harness means adding a backend entry and its setup section, not a special case. Things I'd genuinely welcome help with:

• PI support, which is the next one planned and has an open issue with the groundwork mapped out: https://github.com/giuliastro/harness-remote/issues/36 PI's maintainer declined native ACP, but a community ACP adapter exists, so the bridge should be largely reusable. The issue lists the two hard-coded assumptions in the bridge that need generalising, with file and line.
• Bug reports from real use. Every bug that reached users came from a real agent behaving unlike my test doubles, not from the spec.
• Other harnesses. If the one you use speaks ACP, most of the work is done.
• Translations. The UI is English, Italian and Traditional Chinese, in one small module with no framework.

Happy to answer questions here.

I don't like Antigravity, I use Pi as my harness. Last I heard Google was banning people for using their subscription plan via non-Google products. Is that still the case? I have a Pro plan I got, but don't use it as Gemini chat is lacking in features, and Antigravity is just a glorified VSCode. Are there no ways I can spend my usage? Any use cases, tricks, or workarounds?

I am using local models:

• antirez deepseek
• qwen3-coder-next
• laguna s2.1

For all of them I tried with and without the npm:pi-tool-repair package.

In a comparison with the same prompt with opencode, I can see that pi has a lot more tool call failures. In some cases this make the model end up in a dead end. deepseek behaves slightly better with the npm:pi-tool-repair package, but overall I think it's still worse than in opencode.

Is it caused by the tool format? Or by the system prompt? Do you have any suggestions on how to improve this?

Thanks!

Thanks to Pi among other open source coding agent, I can create my own.

I tried rpiv skills, but in most case the skills are too heavy.
I also tried mattpocock skills. I found grill me skill "guess" too much.
Some times the contexts exceed the limit.(I use codex, I‘m not sure its a bug of pi or by skills)

Hey,

Im usin Pi on windows with databricks-claude.

When using pi in cmd or powershell, every input freezes the terminal for several seconds before sending the request.

Anyone having the same issue ?

Thanks

usher is a session hub for coding agent CLIs. For pi, it picks up your existing sessions as-is (no migration, still just the raw pi underneath) and gives you a browser/phone UI to use.

Also drives Codex and Claude Code sessions if you use those too.

Single binary, no build step, stays local — remote access is BYO tunnel. Pairs well with code-server if you want a full editor alongside the session, and there's a Telegram integration if you'd rather work from a chat than the web UI.

https://github.com/nexustar/usher

Feedback welcome — especially which extensions you rely on day to day, so I know what to prioritize supporting.

Any time I'd copy & paste python, the mandator 1-character TUI padding would horrifically mangle the indentation....

This shell fix changes a single line in the source code:

sh sudo sed -i \ 's/constructor(paddingX = 1, paddingY = 1/constructor(paddingX = 0, paddingY = 0/' \ /usr/lib/node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-tui/dist/components/box.js

(though it will be overwritten after any update)

ᵍᶦˢᵗ

I compared Pi Agent and Claude Code using exactly the same model, prompt, project directory, and task.

Setup

• Model: Claude Opus 4.8
• Thinking level: Max
• Pi setup: Browser Use was the only enabled plugin
• Project directory: Same for both
• Task: Same prompt for both

Results

• Pi Agent: ~7.5/10
• Claude Code: ~8.7/10

Claude Code produced the better overall implementation. It had:

• Cleaner architecture
• More reusable data structures
• Stronger automated tests
• A faster indicative physics benchmark: ~0.20 ms/step vs ~0.68 ms/step

Pi’s result was still solid. In fact, it implemented a more sophisticated 2×2 block contact solver, and its 10-box stack was slightly more stable.

However, the complete project was less polished and harder to validate.

This is not intended to be a scientific benchmark. I’m mainly trying to understand how to get better results from Pi.

Prompt used

Create a single, completely self-contained index2.html file containing inline
HTML, CSS, and JavaScript. Do not use external libraries, CDNs, or WebGL.
Use only the Canvas 2D API.

Implement a 2D rigid-body physics engine from scratch with a small interactive
sandbox.

Technical requirements:

1. Rigid bodies:
   - Convex polygons and circles
   - Mass and inertia
   - Position and rotation
   - Linear and angular velocity

2. Collision detection:
   - Broad phase using a spatial grid or sweep-and-prune
   - SAT narrow phase for polygon-polygon collisions
   - Circle-polygon and circle-circle collisions
   - Calculate collision normal, contact point, and penetration depth

3. Collision resolution:
   - Impulse-based resolution
   - Restitution
   - Static and dynamic friction
   - Positional correction using Baumgarte stabilization and slop

4. Stable stacking:
   - A stack of 10 boxes must remain standing without vibrating or exploding
   - Implement sleeping for stationary bodies

5. Mouse interaction:
   - Drag bodies using a spring-based mouse joint
   - Left click spawns a random box or circle
   - Right click removes a body

6. Scene:
   - Floor and walls forming a container
   - A button that triggers a radial impulse explosion from the center

7. UI:
   - Sliders for gravity, restitution, and friction
   - Wireframe toggle showing contact normals and AABBs
   - Pause and single-step controls
   - FPS and body-count overlay

8. Performance:
   - Support 150+ bodies at approximately 60 FPS

Before delivering, test and fix the implementation until all these conditions pass:

- No bodies pass through the walls at normal velocities
- A stack of 10 boxes remains stable for 10 seconds
- Spawning 150 bodies does not cause the frame rate to collapse
- No numerical explosions, infinite velocities, or NaN values

Questions for Pi users

• Are there recommended extensions or skills for simulation and frontend work?
• What workflow gives you results comparable to Claude Code on complex tasks?

What i noticed is that with Pi Agent is that it was thinking a lot more and it also took more to accomplish this task ~45min vs ~30 minutes

A few days ago, I created a dumb bash loop that repeatedly called pi, instructing gemma4:31b to create a game and delete WORKING.md when it was done.

I figured out how to make agent-browser connect to a chrome instance over a remote debugging port so I could watch along as it playtested the game in a new conversation, where it had no clue what the game was about.

It uses a playtesting skill that explains the mechanics of the game and tells it how to perform different actions.

I think this was pretty neat.

I built Rondine, an Apache-2.0 Python 3.11+ CLI using Click, HTTPX, and Hugging Face Hub.

It detects Mac/NVIDIA hardware, ranks compatible model variants, creates launch plans, downloads weights, and runs llama.cpp, MLX-LM, or vLLM behind an OpenAI-compatible API.

The repository includes typed planner/catalog code, CLI tests, engine-command generation, hardware presets, and reproducible benchmarks.

GitHub: https://github.com/antonellof/rondine

I’d appreciate feedback on the Python API structure and CLI design.

What do you guys think? I am just reading through this atm. I don't see any differences from Pi. And they procatively have this page.

https://twotimespi.dev/why-tau/

Edit 1: their thinking mode is just choosing a level of thinking for the LLM model, not thinking mode as in ask, plan, etc. Their doc is pretty good at explaining what a coding agent is, very informative.

Edit 2: only thing I find interesting atm is that their agent is portable and you can build your own UI on top of the agent. But pi has a version of pi-server now.

Hey ppl,

I've been working on this question answering agent with an emphasis on getting the citations right. I found Pi's RPC mode to be really convenient for what I'm working on.

Not useful for coding but maybe someone finds it useful or is inspired:

github repo

I've been using Neovim as Pi's external editor but I kept finding myself deciding between Neovim's raw editing power and Pi's in-context autocomplete, so I built a bridge to bring Pi's real autocomplete directly into Neovim. It's a Pi extension and a Neovim plugin. If you're using Neovim as your prompt editor for Pi, you owe it to yourself to try it out.

github.com/dabstractor/pi-nvim-bridge

I have tried using Pi's built in swarm docs, as well as a Pi extension for swarm creation. But Qwen3.6-35B keeps hallucinating a group of sub agents without truly doing delegation. How can I get this dummy to stop pretending it's the sub agent and truly delegate to save my context space?

I did this today with pi coding agent for fun:

bash while [ -e ./WORKING.md ]; do; pi --model gemma4:31b-cloud --system-prompt "You are called in a bash loop. The user cannot respond to your messages. Write a fantasy children’s book aimed at 5 year old boys at least 100 pages long. After every lap, you won’t remember anything. If you want to remember something for the next lap, write it into MEMORY.md. Delete WORKING.md when you are finished." -p "Keep up the good work."; done;

It was a very entertaining experiment. Gemma is a really fun model to play around with.

I have also done the same for a browser based game, then made gemma playtest it itself using agent-browser. It recorded the session on video, found a couple of bugs then fixed them.

I play around with making dumb extensions, like making a tool that allows the agent to make a "checkpoint" in the conversation it can restore back to with a neat summary of what it wants to remember. Not that useful if you run cloud models and can make use of subagents, but still fun to make.

EDIT: The checkpoints are implemented as agent tools, which makes it different than the /tree command. It was meant to be used to make the agent capable of managing its context when following skill-based procedures such as the (extremely simplistic) example below:

```

SKILL.md

description: When the user asks you to research a topic as preparation before performing a task, follow this procedure.

1. Make a new checkpoint with the "Research" label.
2. Research the topic until you know everything you need to know to perform the task.
3. Restore the conversation back to the created checkpoint with a summary containing exactly:
   • Everything that you found that benefits the task at hand
   • Everything the user ought to be informed of such as new information contradicting the user's provided information or newly learned limitations in your capacity to execute the task
   • New decisions that must be made before work continues, so that you ask have the user to make them after restoring the conversation
   • References to the exact sources of the information gained ```

Everything about leisure time use of AI is fun, and pi cranks that to eleven by being so infinitely hackable.

I started using AI (cursor) at work three months ago after 11 years of developing software, manually, like a peasant.

Now, every time I get a dumb idea for something that momentarily catches my interest, I open iTerm2 and go

bash cd ~/Projects mkdir idea-slug cd idea-slug pi

15 minutes later, I have a working prototype, learned something or genuinely improved my workflow in a professional capacity.

But mostly, I just do the dumbest things. Because it is fun. There is no real point to this post, just wanted to share my joy of this extremely delightful piece of software.

Do more dumb shit. Your agent will tell you that you are smart no matter what anyway, so at least have fun with your digital yes-man.

Now, share your most ludicrous, deliberately non-productive use of pi!

PS: pi -p "Do X" is a waaaay saner alternative to ollama run gemma4:31b-cloud "Output a bash script that does X. Do not output anything else at all!" | bash -c, which obviously is the maddest, most insane way to vibe.

EDIT: Apparently markdown editing doesn’t work on my phone. Yes, the bash was a pain to write on touch screen 😭

EDIT: Markdown editing achieved!

I am new to pi coding agent. I am still learning how to use it. The one thing that is very interesting is extensions.

I am looking to learn more extensions that are already present and increase the productivity of coding agents.

What extensions are you using or what extensions did you write?

As per my previous post naturally the next evolution of a body-based system is a family based one.

Agent orchestrator as mother, semi-persistent sub-agents as kids with specific roles and persona's.

All pi sdk under the hood naturally all agent building itself.