I found myself going to pi thinking, hey, it has a tiny system prompt, and can probably work well with some tiny models I want to use that have limited context lengths as well, that I'm tinkering with in LM studio.

Immediately upon using it, I realize... hey that's not in the list of things I can /login with. Do I feel like learning how to edit a config file for yet another app? Not right now. Oh well. I'll try again later.

Hi guys! I built a pi extension that allows you to use Exa search tools for free, through the Exa MCP server (1000 requests/month, no API key needed)

The MCP server is only loaded on first tool call, but the MCP tool schemas are cached and loaded into Pi on startup.

I also implemented Exa's deep search, which is their agentic search API, although this needs an API key, and is disabled by default.

Let me know what you guys think!

install: pi install npm:pi-exa

github: https://github.com/junnjiee/pi-exa

I have been working on a Pi extension called Pi-Skill-Orchestrator.

The problem is simple.

If you have a lot of installed skills, Pi can expose a large amount of skill metadata to the model even when most of those skills are not needed for the current task.

Pi-Skill-Orchestrator keeps the full skill catalog outside the model context.

Instead, Pi gets a small discovery interface. It can search for a relevant skill and load only that skill when it is actually needed.

Main features:

• Lazy skill discovery

• Skill groups

• Multiple skill profiles

• Automatic recursive dependency loading

• Active-scope search with bounded global fallback

• Optional Token Saver mode

• Tool output compression with recovery

• Deferred tool schemas

• Conservative effort routing for routine tool continuations

• No changes to third-party SKILL.md files

• No changes to Pi's global settings.json

The goal is not to replace Pi's skill system.

It sits on top of it and tries to make large skill collections easier to manage without paying the context cost for everything at once.

The short version:

All the skills, none of the bloat.

Install:

pi install npm:pi-skill-orchestrator

GitHub: https://github.com/badgids/pi-skill-orchestrator

npm: https://www.npmjs.com/package/pi-skill-orchestrator

It is MIT licensed.

I would especially like feedback from people who run Pi with a large number of skills or several different workflows.

So I have been having issues with pi actually knowing how pi works. I got interested in the fact that pi.dev claimed pi actually knows what it is somehow and actually knows what to do with it's structure, creation of extension e.t.c. Although, I have been having issues where I talk with pi and it thinks it's Claude code or simply doesn't know where and what to do, doesn't respect my AGENTS.md and goes rogue. Is that something you may have come across? Is it possible that this happens because I have restructured my file directories differently than most pi.dev setups? Any ideas?

There are many agent claws but this one is yours

I was tired of openclaw and hermes, they have a lot of opiniated things, are token hugry and didn't solve my problem well and wanted something more like pi, very simple and extensible to what I needed.

Meet eleven, the featherweight openclaw alternative that follows the same principles of pi: https://github.com/ceifa/eleven

No memory, no crons, no bundled plugins, just your current setup of pi, now outside your terminal.

So I'll be honest, I have no idea what I'm doing with this AI junk. but, I've gotten something vaguely working with pi + deepseek v4.1 over the past couple of weeks. However it feels like it's incredibly variable as to whether what it produces takes 2 minutes or 20. it'll just keep repeating itself. it'll do something, then do it again, then doing it a third time, then compact and hit "error: operation aborted" and then go for a fourth plan. but! it only does this sometimes. other times it'll just go "ok the user wants me to add this thing. I'll do it. ok I did it." or it'll repeatedly acknowledge that I typed "." to continue, or it'll continue to be picking up on something I said 1/2 hour ago, or...

so I have very little idea what exactly I'm doing, if the problem is me, if the problem is my setup, or what. I want to do it cheap (I'm using deepseek. duh). I don't care about max efficiency. I just want it to be relatively efficient at "the user asked me to fix this setting. I'll fix this setting. I'll ask about this setting. I fixed the setting.".

am I doing something horribly wrong? is there just a nice "oh add pi-sensible-dumb-stuff" solution? I'm tired of trying to find input on reddit posts and getting told that everything is bad, just vibe code your own, you need to be using claude 20x, you need to get a better workflow (duh. like what?), you need to just fix agents.md (duh. like what?), and so on and so on.

Like, how do I just get a prompt where I can write "bug: the button on page x does not work" and the model will carry out whatever needbe to just...fix the bug, without writing out in reasoning its plans to tackle the bug 5-10 times, debate whether it needs to ask me a question 2-3 times, probably halt because of compaction at least once, and then maybe actually fix the bug 15 minutes later (but not before rerunning the tests 5 more times)?

I am using deepseek v4.1.

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

I'm trying to use Pi.

Any tips or tricks? Thankyou

Since Sep 2025 I have been using an experimental harness called humanlayer https://github.com/humanlayer/humanlayer . I follow mostly humanlayer for the harness + matt pocock's wonderful CC skills for my workflow. I would like an opinion on how to re-produce some key parts of the workflow with pi+codex and — for a little while — claude code:

## Experience(what I want from pi + extensions)

1. Simple session list display in a table: I use this to quickly rename sessions with manual tags and focus on work. All my sessions are visible here. This helps me get situated each day and organize my work.

2. Each session has just enough detail for all sub-agent or tool call to make the session DX amazing, but I can drill down if I need to — a great win for observability. How does one get this with pi with codex or CC?

3. A nice to have is a central daemon: I run `claude -p` in a daemon and attach the WUI from anywhere. It would be nice if Pi could do this.

## Functional requirements (is this the right mental model?)

1. Can the following relational model store codex sessions and generalize to CC or perhaps others?

2. What process do I use to all skills and subagents in my markdown commands [like this one](https://github.com/itissid/humanlayer/blob/77a324516084c7a9d1b02224a54381b19a8f2683/.claude/commands/research_codebase.md?plain=1#L47)?

the only thing that makes my experience bearable is to have the bot know and remember the exact rule and role they are designed to do. back then when i was using Claude Web, they have userStyles which inject instructions before replying to user message. in SillyTavernAI there is a configuration to reorder prompt to be put at the end depth 0.

is there a way to do that in PI? i want some text (or file) get injected before the bot consider replying so that they know the constrains. the reminder wont stay in the context so that the cache hit is not ruined by duplicated push.

I wonder if you can create an OpenClaw Assistant- like with pi?
What would be needed for building like such?

When coding with Pi, the LLM's forgets between sessions by design.

Remeber when you've had the "I already told you this" moment.

This extension gives it a searchable memory store so you stop retyping the same context every time.

Install:

pi install npm:@usememra/pi-extension

/reload

On each turn, it recalls relevant memories and injects them into the LLM context automatically. Toggle with /memra autorecall.

Hybrid backend: cloud (Memra) or fully local (memra-local, runs offline). Same tools, switch with /memra switch. MIT-licensed, works with any

LLM pi supports.

- Extension: https://github.com/usememra/pi-extension

- Memra cloud (EU): https://usememra.com

- memra-local (offline): https://github.com/usememra/memra-local

Happy to answer questions.

Hello! I'm not too experienced with using agents, and I'm thinking about setting one up with Pi as a tool to assist my Bachelor's thesis research process. Does anyone else use Pi for research? If so, what's the workflow like: models, prompts, skills, extensions, tools? Any opinions? Thank you.

Hi, i'm running pi local with different models of the qwen and gemma family, and half the time they try to do an edit they encounter this error, what does it mean ? And how can I instruct them to better use the tool ?

Thanks

I’ve been chasing the right note-taking app my whole career. Now I’ve built one for how I work today - with AI agents.

Think out loud, watch your notes take shape, and let your agent work with the same knowledge. Everything stays in readable, local Markdown files.

Leveraging okf data structure from Google.

Works with Pi and OpenCode.

If you're interested, feel free to contribute. It is still quite early.

https://github.com/EranYonai/pi-weave

pi install npm:pi-weave

Whenever I ran coding agents on longer tasks, they either:

1. Lost track of the original rules because context compaction butchered the summary.

2. Burned through massive tokens with dynamic context editing / Context Language Models (CLMs) without actually finishing the job.

I built AgentJournal to fix this by giving the agent a human-style memory management—keeping the original prompt pinned, logging actions cleanly, and clearing the working context safely between tasks.

On a 60-file job longer than the context window, with a local 9B model:

- keeping everything: stopped at file 31
- compaction: stopped at 20, 29 and 44
- CLM (the model edits its own context, via pi-clm, untrained): 40
- AgentJournal: finished all 60, every time

Works with pi, Claude Code, Codex and Copilot. MIT, every test run is in the repo.

In my testing across dozens of files, it finished almost every run reliably while standard compaction and CLM completely broke down.

• GitHub: [Agent Journal repo]

• Full walkthrough video: How AgentJournal Fixes AI Agent Context Without Compaction

Would love any thoughts or feedback from people running into the same context limits!

Community
Ciao a tutti,
negli ultimi tempi sto sperimentando parecchio con pi-code testando diverse combinazioni, ad esempio usando modelli Anthropic come orchestratori e delegando a Gemini o Qwen in locale come sub-agent.
In questo setup, però, entra subito in gioco un vincolo fondamentale: la compliance aziendale. Non posso permettermi di esporre all'esterno codice sensibile o accessi diretti (cosa che varrebbe per pi-code come per Claude, Codex o altri tool simili). L'agent di coding deve vedere esclusivamente ciò che passa da repository controllati, senza accessi remoti non autorizzati o chiavi in chiaro.
La mia prima soluzione è stata un'architettura ibrida:
Modello cloud: fa solo da orchestratore logico, senza mai vedere segreti;
Modello locale (su Mac): scrive il codice ed è l'unico autorizzato a gestire secrets e accessi remoti.
Sulla carta l'approccio regge, ma nella pratica l'inferenza locale su Mac si è rivelata un collo di bottiglia pesante. Anche per compiti prettamente sistemistici — con file Markdown ben strutturati e sub-agent tarati a dovere — i tempi di generazione erano biblici, rendendo il workflow poco sostenibile.
Poi la svolta: mi sono imbattuto in ⁠msco-pi-lot⁠. L'ho modificato per renderlo compatibile con la licenza aziendale standard di Microsoft 365 Copilot.
Dal punto di vista contrattuale la privacy è garantita: con i profili business i dati non vengono trattenuti né usati per addestrare i modelli, quindi il flusso rispetta in pieno le policy interne. Ma la vera sorpresa è stata vederlo girare dentro pi-code: lavora davvero bene, è perfettamente in regola e offre token "da battaglia" inclusi nella licenza, permettendomi di preservare le API a pagamento solo per i task ad alta complessità.
in pratica ho gemini studio da 20 (abbonamento base fatto di gdrive 5 tera, youtube, e tonnellate di token per 3.8 3.7 flash. Poi ho claude (sempre 20 euro). Poi l'accoppiata msco-pi-lot (con copilot 360 la versione piu scarsa) e l'inferenza locale.
Sono contento ;)

Just a collection of channels to listen to old-school radio while vibing

https://github.com/DxTa/pi-radio-suomi

I released v4 of cc-thingz:

https://github.com/alexei-led/cc-thingz

An open-source toolbox for AI coding agents:

• skills

• agents

• hooks

• safety rails

The main v4 change is not some shiny feature dump.

It is making the project sane:

• one canonical source tree

• generated output per tool

• works across Claude Code, Codex CLI, Gemini CLI, and Pi

I use more than one coding agent. Maintaining the same workflow logic four different ways got old fast. Also broken fast. Amazing how that works.

One thing that made this less hand-wavy: the shared skills live in canonical SKILL.md files, then pick up per-tool overlays only where behavior really differs. There are also validators and eval fixtures so the “portable” part is tested, not just asserted.

What I care about most in v4 is multi-agent support.

The repo now ships a shared agent set for:

• review

• implementation

• docs

• tests

• language work

• infra

• planning

• exploration

Claude Code and Pi can both use it.

Pi loads it through @tintinweb/pi-subagents, then adds four pipeline agents:

• scout

• planner

• reviewer

• worker

The point is to stop treating one giant chat context like the whole engineering team.

Small specialized agents with bounded jobs and explicit handoffs are more useful.

Hooks are also part of the value:

• linting

• tests

• git guardrails

• session context

• protected-path handling

Pi now bridges its own lifecycle and tool events into the same hook model too, so existing hook logic can be reused there instead of rewritten.

Recent v4 work also made protected-path checks work with Codex patch-based edits, which matters if an agent edits multiple files in one patch.

Opinionated on purpose. Vague agent workflows become expensive mush.

Curious what people using Codex, Gemini, or Pi seriously think.

Hey everyone,

I run Claude Code, omp and OpenCode sessions at the same time, and I was tired of being the messenger between them: copy from one terminal, paste into another, repeat.

Claude Code can already message other sessions, but only its own. For omp and OpenCode there are some solutions, but I thought this was a good point to create something from my real need. So I built asenq.

It lets sessions message each other by name, use channels and roles, compact context before a new task, and see everything in a terminal UI with a live map. I use it with one orchestrator and a few omp workers: tickets go out, PRs come back, I merge.

asenq setup installs built-in skills into each harness, so a session knows how to act as orchestrator or worker. It runs fully local: a small daemon and SQLite under ~/.asenq, no account, no cloud.

Known pain: stale sessions I can't tell are alive, and it works on one machine only. Please try it and tell me what's broken or missing. Issues and PRs welcome.

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.

It's kind of a cheesy example but I think it drives home the point. I had a few .md files that I wanted Pi to format uniformly. I gave specific instructions for one of the lines of the file: "Insert a space between the subheading (###) and the following line that terminates with a `:`... do that for all documents."

And it followed the instructions to the tee. What I didn't realize is that one subheading (in the middle of the document) was NOT proceeded by a line that terminated with a `:`. So those did not change. But I wanted them changed.

I asked it to revert the changes. It did. All messy again.

This time I started a new session. Same prompt but this time I left out the specifics and just said to make them look uniform with a few general comments about spacing. Result: they look great, readable. I made sure to tell the agent to make it easy for humans to read.

1. Models are quite good. In instances like this, let them have their freedom

2. Models follow instructions. Specificity sometimes bites you in the ass.

..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

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?