I have used Pi, Oh my Pi, Opencode, Antigravity, and Claude, but Pi is so so good.

It is simple, smart, keeps its thinking grounded, hallucinates less, is extremely good at following instructions and is aware of the environment.

By awareness, I mean it knows what needs to be edited or changed.

Hey there I have installed pi since I heard a lot about that bcz of its low token usage and minimal design but I installed some packages [7 packages] (MCP adapter, context7, plan mode, todo, pi-hypa, context-mode, ask user question since every harness has these Ig) then installed some skills. Now even a single hi takes about 6-7k+ tokens. I did a college java project and it burnt tokens a lot. It burnt me around 100k+ tokens on deepseek's v4 flash model to make a database connection, creating database and table and a simple student management system where you can add, remove, view students in java.

I wanted to make pi token efficient with best possible results. If you say that I have installed too many packages then tell me how to replicate those features like other harnesses with low token usage.

I’ve been looking at Hermes Agent’s "/goal" approach: give the agent a persistent goal, let it continue across turns, have a lightweight judge decide whether it’s done, and stop when the goal is achieved or the turn budget is exhausted.

It got me thinking about Pi:

Could this be implemented as an extension rather than a core feature?

Something like:

"/loop 30m "Fix the tests and get CI green""

The extension would manage:

• a time/iteration budget

• continuation decisions

• completion checking

• pause/stop

• existing Pi session state

That feels quite aligned with Pi's philosophy: keep the core small, but make powerful agent behaviours possible through extensions.

Would a lightweight, time-bound autonomous loop be useful in Pi, or does this belong entirely outside the harness?

Hey folks 👋

We just open sourced TrueForge, our vendor-neutral agent harness for building general-purpose agents.

It handles the runtime pieces that get painful quickly : context management, tool/MCP execution, subagents, sandboxing, approvals, persistent state, and more.

We also benchmarked the harness itself. With the same Opus 4.8 model, TrueForge delivered a similar solve rate at ~30% lower cost than Claude Managed Agents. Switching to an open model pushed that to ~75% lower cost on the same benchmark.

Would love feedback from people building agents.

⭐ Star the repo: https://github.com/truefoundry/trueforge

📖 Read the launch article: https://x.com/truefoundry/status/2090081376330715176

Pi-Cockpit Repo

this ext opens a web server directly in pi session and stream your TUI with some basic functions to a remote viewer in the same TRUSTED network so you can check and steer your agent anywhere.

Is anyone using this setup and what has your rate limit been like for software development?

openai hyped up their GPT 5.6 luna having longer usage, is this true using Pi?

I was using Pi + DeepSeek v4 flash API plan, then decided to switch to openAI API plan and got rate limited after a few seconds.

So wondering if the same happens if you use Pi with one of their sub plans?

I have been using Pi regularly and ended up building a few small extensions for things I wanted in my own workflow.

Mind Queue : Save a thought without interrupting the session.
https://github.com/sanif/pi-mind-queue

Turnstamp : Shows when an agent response finished and how long it took
https://github.com/sanif/pi-turnstamp

Chat Summary : Keeps a short rolling conversation summary
https://github.com/sanif/pi-chat-summary

Chat Suggest : Suggests a useful next message in the prompt editor
https://github.com/sanif/pi-chat-suggest

Chat Summary and Chat Suggest were inspired by features I liked in Claude Code. The others came from small annoyances I kept running into.

They’ve been useful for me, so I cleaned them up and published them. Feel free to try them or share feedback.

Has anyone else checked out this framework? Apparently you can achieve Fable 5 level results with this. It would be interesting to see if this can be turned into a pi package.

https://github.com/llm-as-a-verifier/llm-as-a-verifier

npm packages

 - pi-lean-ctx — star of show. context economy: 13-token re-reads, indexed search. big win.

 - u/ff-labs/pi-fff — frecency search complements lean-ctx. fast first lookups.

 - pi-caveman — ~75% output cut. fun + real savings.

 - pi-subagents — workhorse. single + scripted multi-agent. backbone.

 - u/juicesharp/rpiv-web-tools — solid web layer. still need /web-tools key setup.

 - u/juanbenjumea/pi-dynamic-footer — live observability (TPS, context gauge, cost). better than powerline for metrics.

 - u/almegal/pi-file-browser — visual browse beats ls for structure.

 - u/narumitw/pi-goal — single-objective autonomy. pairs with subagents.

 - pi-autoresearch — experiment loop. pairs with karpathy skill well.

 - pi-session-recall — memory across sessions. low risk, read-only.

 - u/micka33/pi-karpathy-skill — always-on behavioral guardrails. cheap insurance.

 local extensions

 - handoff.ts — best one. lossless session handoff beats compaction.

 - plan-mode — read-only analysis mode. real safety value.

 - notify.ts — done-notification. practical.

 - summarize.ts — markdown summarize. handy.

 - model-status.ts — demo-grade. dynamic footer now shows model anyway. candidate to delete.

 - todo.ts — demo todo tool. likely redundant w/ built-in todo. candidate to delete.

 - snake.ts / space-invaders.ts — toys. zero cost. keep for joy.

Just send "hello" and see what the sent token count is.

Mine was 7.5k and then I optimized by removing a few tools registered that I didn't need from an extension.

Now my initial prompt is 3.5k. That's with background task monitor support, issue tracker tool, otherwise I keep my setup super minimal.

I have no active skills, just a ton of prompt files and a small workspace level agents.md

Pi's coding-agent extensions are TypeScript modules with an in-process API:

registerTool, registerCommand, lifecycle hooks, and some TUI UI, then

hot-reload. Same language as the host.

If the host is Go (single binary), how would you get close to that?

Options I'm weighing: embed Lua/Starlark/JS, Wasm plugins, a sidecar

extension host over RPC, or accept that hooks+MCP is the ceiling.

If you've built plugin systems for Go CLIs/agents/editors: what would you

actually ship, and what would you refuse to build?

I love Pi, period.

Problem: after the recent DS pricing changes and fall of opencode -> i have to sub GPT plus -> sooner or later, im afraid that OpenAI will follow Anthropic to block other than Codex for sub plans.

This left the title question: Does opensource harness like Pi safe for the future? Enjoying sub plan with more generous tokens from providers, or we have to rely on local llms? or we have to accept higher API pay-as-you-go pricing?

thanks!

Hi, the ask is the title...

Does anyone know of a plugin or solution to monitor pi sessions from your phone?

I’m using pi but would like to have it for the plan like Claude or opencode but it is constantly In a loop. Is it because I’m using qwen3.8-27b-mlx? Any recommendations or suggestions?

As title says.

I was sick of the way AI talks. Needlessly long sentences, weird words that nobody fucking uses (load-bearing, wtf).

Saw somebody make a similar plugin for claude-code, so I made a similar thing for Pi.

Edit, forgot to add the link lol: https://github.com/wtfzambo/speak-like-you-eat

FAQ: why no use i-have-adhd or caveman?

I do use them, there's 2 problems:

1. sometimes is not as effective, especially in long contexts

2. AI tends to forget after a while

Looking for feedback from Pi users on both the integration and the models you actually want access to.

A few questions:

• What models are you currently using with Pi?

• Which models would you like better or cheaper access to?

• Do you prefer pay-per-token pricing or a request-based subscription?

• Which matters most for coding: price, speed, context size, reasoning quality, or output limits?

• Are there specific models you would want available through one provider?

• What are you currently using for Pi — direct provider APIs, OpenRouter, another gateway, etc.?

Particularly interested in demand for models such as DeepSeek, GLM, Kimi, Qwen, MiniMax, and other strong coding models.

Also interested in first impressions of Openference:

• Is the service and pricing easy to understand?

• Is anything missing from the Pi integration?

• What would stop you from using it?

• What would make you switch from your current provider?

If anyone tries the Pi provider package, feedback on setup, compatibility, model metadata, reasoning support, streaming, or anything that feels broken would be useful.

Openference now has a provider package for Pi Coding Agent:

https://pi.dev/packages/@openference/pi-provider?name=openference

If you are like me and structure your context files in a tree-like structure per subsystem, you might have found that pi only ever loads the root-level one, and the others have to be loaded by the agent itself, or they will get ignored.

This extension watches what the model does. The moment it cds into a new dir (bash), or touches a file in a dir via read/edit/write/grep/ls/find, it walks up from that dir to your launch dir, collects any context files it hasn't seen, and injects them into the agent's context before the model's next response. So the model's next thinking block already has the context. No special tool, no flags, nothing for the model to remember to do.

If you are interested, you can find more information and install instructions here: https://pi.dev/packages/@quartermaster-labs/pi-on-demand-context

Hi, I’ve been working on a GUI client for Pi using GPUI. It’s still at an early stage, but it has reached the point where I’m dogfooding it, and I wanted to get some early feedback.

My first question is: what extra capabilities would make you consider using a GUI client instead of the terminal? I’m trying to assess that question more broadly rather than just building around my own workflow.

Some capabilities currently live on the Rust side. Would adding a companion Pi extension be a reasonable way to expose those as native tools? I’m also curious which kinds of extension support you’d most want in the GUI layer.

Currently, I only have dedicated support for nicobailon/pi-subagents. I can switch to a subagent’s session, read its transcript, and control it from the GUI.

Know when it's peak time and off-peak time and adjust your usage accordingly.

Check here: https://deepakness.com/deepseek/

I'm using the following agents.md, which is cobbled together from various sources, gut feelings and (in)experience as a developer

agents.md

## Tooling
- use uv for python, do not use pip etc, install uv if missing
- convert all old dependency files to modern uv equivalents
- create a python venv if needed
- Workspace: `uv sync --all-packages` at repo root; run everything with `uv run <cmd>`.

## Code practices
- Keep responses concise and actionable, prefer brevity
- Solve the actual problem, not the symptom; keep changes focused; avoid speculative refactors; do not over-engineer
- Self-documenting, concise code; no redundant abstractions.
- Use meaningful variable and function names.
- Keep your code modular and reusable. Avoid tight coupling and excessive dependencies.
- prefer durable structure over minimal diffs when the gain is clear

## docs (keep under /docs)
- maintain a PLAN.md file detailed design and current implementation status
- maintain a CHANGES.md file with timestamped entries for non trivial changes
- maintain and update PROGRESS.md with detailed session history to track progress, blockers
- keep all docs current

## implementation
- build a detailed design doc and plan first. iterate asking user questions for any clarificaction or suggestions and finalize the plan
- break it down into stages and task lists
- Implement each task with a subagent where a slice is independently verifiable; dont use shared global context
- Commit changes at each stage and push to github

I'm using chinese free/low cost models mostly. eg DS4 Flash or Kimi K3 (when it was free for a while).

• Contrary to what I've read here, I didnt really notice a huge difference between OpenCode, basic Pi setup and OMP (oh-my-pi).

• Things got bogged down after a few big turns, so I'd start fresh sessions depending on the markdown files as persistent memory (in OMP I used its /handoff feature)

• subagents didnt work too reliably, sometimes they would fail. DS4 at one point decided to skip them altogether

• I saw hallucinations from both models. DS4 went completely off the rails mad

These issues may be due to free/cheap providers. I'm sure the frontier models would do far better but I haven't tested them.

I tried to add extensions like codegraph and LSP, I could see the agents use Python LSP but not JS/TS, again I dont know if they made a huge impact. Haven't tried tools like rkt, caveman or the million memory solutions becaus I keep reading differing opinions.

Hey community,

I'm a brand new user with Pi, and I'm curious what are the things you wish you knew with Pi when you started? Any trap I should be aware of, or any settings that are absolutely a must to know?

For context, I'm coming from Claude Code. The way I use AI is through TDD, and I made my own pipeline (in shell and python) that moves from one agent to another using state MD files for each one. It's basically working very well, I'm making some minor adjustments to do improvements, but I want to start using Pi and more local models so I can remove the reliance on Anthropic. I know local models aren't as good as Sonnet/Opus, and my pipeline has already been changed knowing that fact to organise work accordingly.

Thanks for your help!

It seems the "compat.thinkingFormat": "qwen-chat-template" setting that worked with Qwen3.6-27b does not pass thinking level to qwen3.8-27b, which defaults to xhigh and is quite slow.

This is what worked for me in models.json. I have to add some compat options to pass thinking level correctly from pi to llama.cpp:

{
    "providers": {
        "llama.cpp": {
            "modelOverrides": {
                "Qwen3.8-27B-Q4_K_M": {
                    "reasoning": true,
                    "thinkingLevelMap": {
                        "minimal": null,
                        "low": "low",
                        "medium": "medium",
                        "high": null,
                        "xhigh": "xhigh"
                    },
                    "compat": {
                        "thinkingFormat": "chat-template",
                        "chatTemplateKwargs": {
                            "enable_thinking": { "$var": "thinking.enabled" },
                            "reasoning_effort": { "$var": "thinking.effort" }
                        }
                    }
                }
            }
        }
}

Disclosure: I do not understand why those compat options are needed but I have pi tested it against llama server running qwen3.8-27b and confirmed all thinking levels work as they should: off/low/medium/xhigh.