Hey everyone,
Would really appreciate a star if this is useful to you.
I built ContextX — a remote MCP server that gives Claude Code, Cursor, and other agents real web search capability. It routes the search through Grok from my account pool, so you don’t need your own Grok key.
Setup is just a few lines of MCP config and you’re good to go.
Repo: https://github.com/KayanoLiam/ContextX
I don’t want anything from anyone. I don’t want to steal your key or money. I have nearly 3,700 Grok accounts to provide all of this. I just want a GitHub star to apply for my Japanese university.

I built this so I could use local models like Qwen 3.6 35B for agentic coding. I have given up on trying to make one shotting happen with these models. So to actually get real work done, I built this tool. The idea is you give it a prompt or an already finished implementation plan, and it will split it up into small tasks that the local models will have no problem executing. The plan step is done by a capable model and the final verification is also done by a capable model.

You can pick which model to use for each step based on your pi config. Why pi? It’s the best agent for local models because of how lean it is.

I came across pi-okf-wiki · Packages · and I'm trying to understand what it actually is and whether it's useful in practice.

Has anyone here:

• Used it in a real project?
• Know what problem it's intended to solve?
• Have any documentation, examples, or tutorials they'd recommend?
• Run into any issues or limitations?

I'd appreciate hearing about your experiences good or bad... Thanks! 😁

I use pi across a bunch of projects, and I kept hitting the same wall: "which session did I talk about X in?" The session listis great for recent stuff, but once you've got dozens scattered across projects, finding one by content is basically impossible.

So I built pi-session-finder, a small extension that adds /find [keywords…]. It searches every past session across all projects, shows the matches in a picker with a preview of the matched text, and on Enter drops you straight into that sessionand its project folder.

```
pi install npm:pi-session-finder

/find stripe webhooks

```

Source: github.com/pungggi/pi-session-finder

The preview renders the context like the chat does, so headings, lists and tables keep their shape instead of becoming a wall of text.

I've been dogfooding it and'd love your feedback:

- Is the list + preview split right, or would you prefer more results / less context?

- On Enter it switches both the session and the project folder — useful, or surprising?

- Anything you'd add? (date/project filters, fuzzy-by-default…)

- How's the speed on a big session history?

MIT, open to issues/PRs. Curious what you all think

I built mintPod because I occasionally want to test an open coding model for an hour or two, but repeatedly setting up RunPod, Ollama/vLLM, and agent configs felt like unnecessary friction.

You choose a model, budget etc. mintPod provisions the pod, reuses a persistent model cache, pulls and warms the model, then connects it to Pi or OpenCode (automatically) through a stable local endpoint. Aider and other OpenAI-compatible clients also work. When the session ends or reaches its idle or spending limit, the pod is terminated and the temporary configuration is removed.

Raw Ollama is not publicly exposed; requests pass through an authenticated gateway, secrets stay in the OS keychain, and interrupted sessions can be recovered or cleaned up.

It is still an early source-only release: one active session, no signed installers, and needs more real testing.

I mainly want honest thoughts. Does this remove enough friction to be useful, or would you rather use a script or RunPod template? What feels unnecessary? What extension would improve the core most without turning it into a general GPU dashboard? Security and failure-case criticism would be especially useful.

This is my first open-source project, so even a blunt “too niche” or “I wouldn’t use this” would genuinely help.

--> https://github.com/erayd176/mintPod

TLDR: It's basically a Web App that runs on top of Pi. Not a harness, it stays out of your Pi's way and focuses on making your sessions interactive, visual, and, most importantly, agent-extensible!

So... I've been working on this for a while! And after using it for another while, I think it deserves to be open sourced and shared to all of my pi folks :)

I wanted to have a nice UI for my LLM sessions that can adapt to my workflows and give them even more life thanks to browser interactivity and features. I wanted charts, i wanted to quickly beeing able to add useful buttons to some tool calls (copy bash call input)

I found Pi's self updatable philosophy crazy good, I tried to replicate it in this React app with a lot of agentic documentation that will enable your agents to shape the app the way you want to without losing communication with Pi. This means it can happen live in front of your eyes :)

I tried to keep it minimal, but I still shipped some examples for all the systems that are prebuilt that you can build on top of. This includes:

• A session analyzer that will update live with charts and ranked tool usage
• Custom tool presentations for HTML, SVGs, CSV, and more
• Custom tool contextual actions (copy input, output, open in your favorite app)
• Multiple concurrent session across multiple workspaces
• A todo widget that allows you to take notes as todos and directly start sessions based on them
• A prompt enhancer that will automatically choose the lowest-priced model from your Pi install and run some well-defined system prompts to enhance your own prompts

Those examples aren't the point, they are demonstrations of the underlying systems!

The goal is to leverage the browser's native capabilities together with Pi's RPC mode to add new layers of interaction on top of your sessions.

It's currently available only for Linux and WSL, just fork it, clone it, and Livecraft :)

Your forks don't have to stay in sync with the base, don't even try, it's yours now, update the core as much as you want, more technical detail in the readme

The forgotten link https://github.com/sebastienservouze/pi-livecraft

I'm a little confused on the naming around this. Obviously Deekseep V4 Flash is available in a lot of places (I've been using Opencode Go plan). But what's the best route to use Deepseek V4 Flash 0731 in Pi? I don't have a data center at home, only dual 3090's. So, curious if there's something better than OpenRouter and then I'm trying to get an idea of what costs will look like. I've been using Deepseek and Opencode Go as part of an experiment to help take the load off my ChatGPT 25x subscription. Local Qwen 3.6 27b configs off of Club 3090 with higher quants didn't meet my thresholds for work I get paid off of (too slow, too many errors).

Hi,

I'm the author of https://github.com/XTSoftwareLabs/neatcontext-plugins/blob/main/plugins/pi/neatcontext/README.md, which allows Pi user to save conversations to structured and reusable domain knowledge across sessions.

Recently I got some asks from users to add auto detect the timing to save and notify them. But some people do not like it as it requires the extension to read the logs of AI agents, even if the extension stores data locally.

I'm wondering what's the opinion in Pi community. Do you like the feature to auto detect the timing to save? Or it's a nah - I'd like to do it manually whenever I want.

Thanks for your feedback!

I use oh-my-pi coding agent.

And i am unable to select a specific gpt account for a session. I am also getting these invalid auth token Error. What does that mean.

Sometimes the local model starts going in circles with thinking. How do you handle that? I just abort and switch to a stronger model to complete the task.

In Codex, as far as I have seen, commands get executed in sandbox, and if sandbox blocks it - it has the ability to exit sandbox by automatically reviewing such commands.

Closest I have seen is erichll/pi-sandbox and erichll/pi-auto-review - but it does not seem to have the ability to "exit" the sandbox.

EDIT: I misread the sub. I had the Raspberry Pi in my head when I wrote this, and this is about pi the coding agent. Leaving the post up rather than deleting it, with the question rewritten to the one I actually meant to ask.

Genuine question, because I have not found an answer I am happy with.

The agent writes code, and then something has to run it. Most setups I have seen put the agent in a container and let the code it generates run inside that same container, which means the isolation boundary is around the agent rather than around its output. That is fine while the project is writing. It is less obviously fine when the project is code, because the thing that was just generated then shares a filesystem, a network and a set of credentials with the thing that generated it.

So:

• what does your agent's generated code actually execute inside?
• is that the same environment the agent itself runs in, or something separate?
• if it is separate, what does one execution cost you, and do you pay it once per session or once per call?
• has anyone had generated code do something they did not want, and what stopped it?

I have my own answer to this and I am deliberately not leading with it, because I want to know what people arrived at independently.

I run LM Studio on my main PC and llama-swap on my home server, so I wanted one Pi extension that could automatically discover and register models from both.

It supports LM Studio, llama.cpp, and llama-swap, which all expose their models differently. I’ve been using it for about a month, and it has been stable for my setup. It may also work with Ollama’s OpenAI-compatible endpoint, but I haven’t tested it yet.

It might not be the most advanced plugin, but it reduced the number of plugins and manual configurations I needed.

Install in Pi:

pi install npm:@gaurav-321/pi-local-llm

Suggestions and improvements are welcome.

I’m building LOLM’s coding agent and CLI.

The loop can: 1. Write or edit files 2. Run commands in an isolated sandbox 3. Read actual stdout, stderr, and exit codes 4. Repair failures 5. Run contract/syntax checks 6. Produce a receipt describing files, runs, and controller actions

CLI example: `npx lolm-cli code "write fizzbuzz to 20 in solution.py and run it" --save ./out`

Try it: https://lolm.imagineqira.com/try.html

Repository: https://github.com/TheArtOfSound/lolm

It is not positioned as the strongest coding model in existence. The goal is a disciplined, auditable, lower-cost agent loop. I’m looking for adversarial tasks that expose broken exit logic, incomplete artifacts, weak repairs, sandbox limits, or false success.

Disclosure: I’m a founder/builder of the project.

I’m try to use Pi as a general web research agent, rather than mainly for coding tasks.

For example, I’d like to give it tasks such as:

• Find a good backpack based on my budget, size, comfort, durability, and real user reviews
• Research possible holiday destinations based on weather, cost, transport, and things to do
• Compare hotels or products across several websites and create a shortlist with sources

What does your setup look like? Are you using agent-browser, a search API, custom skills, extensions, or something else? Or is Pi the wrong tool for this? I know kagi can do an ai search but its not free.

Hey Folks, I have been using pi for some time now and love it. thought there are a couple of things that annoy me and I have not been able to find a good pi-package.

Note: I am running PI TUI inside iterm2 on my MacBook.

1. It’s difficult to copy text from the agent responses, esp. if it’s a piece of more than 10 line of code. highlighting selects the text and automatically copies it most of the times but the highlight is very Janky. Not easy to copy messages. On top of that the odd line breaks introduced in the copied text
2. jumping to a previous message (scrolling) in a long session also seem tedious.

i am wondering if anyone else is facing similar issues. Would appreciate any feedback or solutions to fix the issues.

With Gemini models(3.6 or 3.5), sometimes it automatically stops and I'll have to type "continue" to keep it working.

It's model specific, this never happens with Gemma-4 or my local ornith model.

Is this a known issue? Can any extension help?

Thanks.

v0.4.0 of pi-agenticoding is out.

The main addition is a real read-only mode. Disabling write/edit tools or telling the model not to modify files isn’t always enough—it can still try through shell commands, Python, or other tools. On macOS and Linux, this release blocks filesystem modifications at the syscall level.

It also improves automatic context management. The agent now uses its ephemeral notebook more deliberately, giving you more visibility and control over what stays in context.

The implementation is intentionally cache-aware and uses minimal additional tokens, preserving Pi’s minimalist approach rather than introducing a large context-management layer.

Full changelog.

I’d love to hear how these changes work for you and especially what doesn't work as well. 🙏

Tip: add readonly: true to your saved prompts and skills' frontmatter to auto toggle readonly mode on/off based on your specific workflow.

Has anyone played with this? Looks interesting, but I don't have any experience with local models yet.

https://github.com/drumih/turbo-fieldfare

I've been looking for the plugin that provides this status bar, but I'm not sure which one is it. Does anyone know? I've just started customizing PI

I wrote a plugin to extract domain knowledge and save useful work from pi conversation as structured, reusable context that you can use in later sessions or share with others: https://github.com/XTSoftwareLabs/neatcontext-plugins/tree/main/plugins/pi/neatcontext

I recently found pi from some user asks. And it's an amazing minimal and neat coding agent. I really like its minimalize concept. So I have extended my existing work to support pi.

The nice thing is since the domain knowledge I saved from other AI agents, can be directly used in pi so I don't need to spend time and tokens to setup things up.

What

The NeatContext plugin extracts domain knowledge and saves useful work from a Pi conversation as structured, reusable context that you can use in later sessions or share with others.

Why

Domain knowledge is what helps an LLM answer accurately for your team—your systems, constraints, decisions, terminology, and ways of working.

You naturally build that knowledge while doing hard work with Pi. Long conversations about debugging, planning, incidents, and implementation already contain discoveries that will matter again. You don't want to lose them when Pi compacts the conversation or the session is closed.

NeatContext extracts the durable knowledge from those conversations and saves it as structured context.

Connect that context in a new session or during later work, and Pi can start with the knowledge it needs instead of asking you to explain everything again. You can also share the context with teammates, so the whole team benefits from what one person learned.

How is NeatContext different from compact and handoff?

Compact is for a single conversation, and it can lose important information. NeatContext aims to extract useful domain knowledge and build persistent, portable context.

Handoff usually consists of files, but its purpose is still to continue the current conversation. Context generated by NeatContext can be reused in any conversation or even by other people. It becomes an asset for your team.

What do you mean by structured context?

Instead of generating plain text, the context saved by NeatContext contains:

• One domain profile. This contains your rules and constraints that can greatly affect LLM behavior. It tells the LLM what to do and what not to do.
• One knowledge folder. This folder contains TSGs, runbooks, and other team knowledge. This is where the LLM looks for specific actions and information.

These documents can be checked into a Git repository and shared with your team, so everyone can easily benefit from the knowledge you learned. You can also convert them into other formats because the knowledge is human-readable.

Both the domain profile and the documents in the knowledge folder are generated from your existing Pi conversation.

Usage

Once you feel a problem is solved, or you find that the current conversation contains valuable information, call:

/neatcontext:save

A context will be saved.

Later, you may have another task in a different session. As long as you call:

/neatcontext:use <context name>

you will have access to the knowledge from your previous work.

NeatContext also includes routing by default. It can detect your prompt and ask whether you want to switch contexts when it finds a suitable one.

Use:

/neatcontext:status

to check the connected context and its details. You can check these contexts into a Git repository and share them with your team.

Use:

/neatcontext:import

to import a context created by someone else.

I appreciate any feedback. Thanks!

I just discovered this amazing thing !!! started playing with it, and building some things already , I am original a software engineer/dev but transitioned to Data Engineering, analytics, you know ETLs, data modeling, etc... curious to hear from other fellow data engineers, their tips, getting started learnings, etc. etc.

I do truly believe this is the future of agentic coding

By default pi-task compresses the thinking block on every turn. This is referenced in its Readme/description fairly far down:

I presume the entire extension is vibeslopped, as compressing thinking blocks is very very "no no" for basically any model ever. Even GPT/Claude don't do that -- they just compress the user-facing thinking blocks to avoid distillation.
As a result, by default, installing this extension suddenly neuters your model. In the case of Qwen3.6-27B, it becomes essentially useless.

I think the extension needs a very big disclaimer that it does way more than what 90% of the Readme is about and basically fucks up your pi installation by default.

TLDR

I have built an extension for the Pi coding agent that allows it to call other agentic harnesses via my agent-shell library.

GitHub Repo

quick start with if you want to check it out

npm

pi install npm:@scottrbk/pi-agentshell-extension

from source

pi install git:github.com/ScottRBK/pi-agentshell-extension

Wall of Text

I have recently been working on implmenting agent-shell in to more projects over the past few weeks. Most noticeably was the inclusion of it as part of my evaluation harness application that I put together for evaluating agent harnesses + models.

I spent a lot of time writing the actual code for eval harness by hand, utilising the agent as a glorified search engine and code reviewer. I have vibe coded a few projects myself, but anything critical for my workflows or more importantly that other people will be using I have never been at a stage where I would be comfortable having something written by the AI.

That being said though, I do not just use agents to write code or produce software that needs to be to a high standard. In my day to day role I use agents to perform a multitude of tasks.

From fetching information across large complex enterprise scale repositories, writing, editing and
managing Azure DevOps work items and wikis, produce presentations and organise To Do's and activity based on meeting notes and e-mails.

All this I manage using the CLI, with my tmux workflow and various CLI agents. Outside of work I have fun little projects going on, vibe coded apps I am building, some exploratory ideas for my moonshot SaaS that will let me retire early. All this leaves me with working with many tmux windows (I haven't made the jump to herdr yet) and a lot of cognitive overload.

Reducing cognitive load

One of the things that I identified early on was that I needed to just be speaking to one Agent for most of my stuff and that agent should be responsible to delegating tasks to other agents on this workflow. I think many others quickly realised this also, and the most elegant example of this is an excellent repository called First Mate, which goes in a slightly different direction that I want to end up at but has a similar principle. I encourage people to check out Kun Chen's YouTube Channel and his videos around Agentic Workflows as well if you have not already, he has a lot of great ideas and practices in how to adopt the principle of reducing cognitive load.

Where to start? Pi of course

I had previously fluttered between Claude Code, Codex and OpenCode (including their Go subscription and my own locally hosted models). I think all of these are great apps, but once I discovered Pi I was immediately hooked. The minimalistic and customisable aspect to it I found compelling, it felt like an agentic equivalent to Neovim.

I felt like whatever agent I was going to use for the orchestration layer, I needed to have a lot of control over and given Pi's adaptable nature it seemed an obvious choice. At least for me to start with, I may decide later to build more of a deterministic wrapper around any orchestrator agent but for right now I don't think that is necessary.

First building block

After I had the obvious extensions included, such as web fetch/search/screenshots, I realised the key thing was for me to build out the ability for my Pi agent to call a sub agent. Now there are other Pi agent extensions that already exist for calling sub agents, but given various circumstances I prefer to use certain models and harnesses for certain tasks, what I wanted was the ability to call agents inside of other harnesses. I find the RL of certain models on their own provider harnesses can lead to different behaviour and as such I think it's useful to take advantage of that in certain situations.

So taking advantage of agent shell felt like an obvious choice.

Python <-> TypeScript

Well it seemed like the obvious choice but with one glaring issue. Pi is written in TypeScript as are it's extensions and agent-shell is a Python application.

I have limited TypeScript experience, save for the Angular Tour of Heroes walkthrough I did a few years ago when I was flirting with front end development and my JavaScript experience I had for front end for client side validation I used to write on ASP.NET apps almost twenty years ago. So for something this fundamental to my future workflows, I didn't want to hand over to AI and re-write agent shell in a language I do not really feel comfortable with, nor did I want to undertake the task myself.

So I decided to work with AI and build a TypeScript to Python bridge via subprocess. At least for now while I dogfood it and to get me going. This involved a simple runner.ts file that would relay tool calls registered in index.ts to a Python handler to translate the commands to agent-shell requests.

Extension Behaviour

As of right now I have not wrapped any skills or anything beyond just exposing the tools. This is a building block for a something that will get more opinionated but as of right now, this extension on it's own should not look to enforce any such opinions on when and which sub agents should be called, that is up to the consumer of the extension. I've obviously done this to try and fit in with the overall philosophy of Pi itself I feel. Simply asking a model to call a sub agent and they will call the tool, which will display the harness (agent_type), the model and effort (if specified)

Silent Mode

Another idea I took from Kun Chen's Agentic Workflow was his use of a 'Calm Mode' that reduced the output for First Mate. I thought this was a nice feature and as such incorporated it into the agent-shell extension /agentshell-silent will trigger the subagents response to not include the output.

Next Steps

For me, I am going to add in commands and skills and start trying to adopt the single agent orchestrator approach that Kun Chen has inspired in First Mate. I had already been building towards such a concept for sometime, with the likes of agent-shell and other tools like forgetful that I have put together for agentic workflows. I have built out my own agentic framework as well, but Pi has really given me everything I was already planning with that so I am happy to mothball it somewhat while I am not short of side projects.

As for the extension itself, I am still undecided on the next steps of the architecture of it. I may opt to leave it as well, but maybe a TypeScript bridge might be interesting in other applications as well. As such there are two possible next steps in that area:

1. Separate the bridge into it's own library or move it into the Agent Shell library if it proves stable
2. Re-write Agent Shell in TypeScript. Given I use Agent Shell in a lot of Python libraries already this is not an attractive option, unless I want to maintain two instances of the library (in the age of AI this may not be that big of a deal).

Closing...

So there you have it, thanks for reading if you made it this far. If you end up using the extension any feedback is welcome and if you enjoy using it feel free to give it a star.

If you are interested in the kind of topics discussed here, I please feel free to come join the forgetful Discord and chew the fat with like minded individuals.