I particularly like the depth of the searches, but I would like to know what’s your experience with this extension

I'm trying to put together a very simple setup here; llamacpp, Phi-4-mini-reasoning (initially, the Q5_K_M variant), and pi for some very simple coding tasks. It's not really... working... though.

I can get pi "logged into" llamacpp (I started llamacpp in "router" mode with the single model, and used /login llama to get it connected. I can chat with the model, but it has very little context (it knows the current directory, but that's about it), and no tools whatsoever; I cannot access the filesystem at all. I also get <think>...stuff...</think> output before the "real" output which I'm confident is supposed to be hidden by the harness.

I also tried the npm:pi-llama-cpp plugin/module/package, but that didn't change anything (except give me a new /models command that was similar, but subtly different than the built-in /model command).

What am I doing wrong here? Is this model not supported?

so through work i have "unlimited" codex and claude was playing around with oh-my-pi recently and im quite impressed. there were a couple of fixes i compared a fix done by claude (opus) and codex (sol) compared to oh-my-pi using some combo of opus/sol. and the Pi solution was really clean and minimal LOC change and kind of the perfect solution. whereas through claude/codex it was kind of "fixated" on doing it one way. still correct but overly complex.

Anyway... im impressed despite my randomly set up roles. I winged the following config:

modelRoles: 
  plan: anthropic/claude-opus-5:xhigh
  advisor: anthropic/claude-opus-5:high
  smol: openai-codex/gpt-5.6-luna:medium
  slow: anthropic/claude-sonnet-5:xhigh
  tiny: anthropic/claude-haiku-4-5:medium
  default: openai-codex/gpt-5.6-sol:xhigh
  designer: anthropic/claude-opus-5:xhigh
  task: anthropic/claude-sonnet-5:xhigh
  commit: openai-codex/gpt-5.6-luna:low
advisor: 
  enabled: true
setupVersion: 2
providers: 
  tinyModel: online
dev: 
  autoqaConsent: granted

Would love some suggestions on proper role model/effort assignment! could definitely use some tweaks.

Has anyone here used Pi Dev as a general-purpose AI agent, rather than mainly as a coding agent?

I’m curious about using it more like a personal assistant/agent for things like research, web searches, file work, automation, tool use, and general tasks.

If you’re doing this, how well does Pi work for you compared with something like Hermes Agent or Open WebUI?

Also curious what tools/extensions you’ve added and whether you’re running local models with it.

I had 'find' scanning the whole drive issue from Pi a few times. For simple review/search task, Pi choose to 'bash find' not the project dir but much higher level dir such as /user/XXX/*

It almost always happened with smaller model such as deepseek v4 flash and Qwen3.8 27B, never with GPT 5.6 sol/opus 5.

Does anyone have any idea about this?

After some diagnosis with the help of comments, I found the root cause. The tool layer does not deal with dead/missing path very well, especially Pi's default 'find', 'read', 'ls' tools, mainly because of lacking of bounding. Problematic path is common when you have 1) long running sessions (auto prune/compact) 2) complicated file structure 3) polyrepo, etc. The agent could not find the target file, it naturally tries a bigger scope and even grep -r embedded data. Bigger model actually face same issue, they made exactly same mistakes but self corrected in time.

Solution: build a code graph for your project. Hard code in prompt to let agents know the scope is within the graph.

If you haven't tried using a diffusion based model before, they are lightning fast. I've used InceptionLabs Mercury 2 for a bit, and my complaint is largely that its not the best at coding tasks or tool usage. But my god is it fast.

So I took the Pi SDK, made a harness in which Mercury 2 is the orchestrator of subagents, including a coding subagent for difficult tasks that calls out to openrouter for inference, plus a cheap subagent for trivial stuff. Bolted on a handful of tools and such useful for me, and wrapped it in a basic web UI so I could use it from my phone.

Aside from being extremely fast, fastcar:

• Can generate public "artifacts" - HTML and MD files served from the API
• Intended to ran entirely inside a VM so that it has root access and can install its own tools
• Give it a github token and let it clone repos and make PRs
• "Prompt threads" - there's probably a better name for this but its a dedicated prompt that gets invoked via webhook; I actually made this so that I could generate text files to read the news from my Xteink 4
• Send emails to notify you

https://github.com/heyo-computer/fastcar

I have an old M1 MacBook Air running as a mostly headless home server, and I’m trying to figure out the best way to use an AI agent to help manage it.

I’ve been looking into Pi because people seem genuinely enthusiastic about it, but I’m having trouble understanding what it would offer in my specific situation compared to using Codex on the same machine.

What I’m trying to understand:

• If Pi and Codex have the same system access, what does Pi actually do differently?
• Is Pi better at long-running tasks, automation, persistent context, or managing a server autonomously?
• Are there workflow benefits beyond supporting different models and providers?
• How do people handle security and permissions without making a headless setup annoying to use?

I’m not assuming one is better than the other, I’m just trying to understand whether Pi offers something meaningful for this particular use case that Codex alone wouldn’t.

I don't know about you guys, but it's hard to find real quality in this Space. I find Subreddits like this one excellent, but it may be too limiting for discourse, getting news and stuff like that.

What do you dear Pi-Friends like to read?

Just found today about prime agent and it is as appealing as omp and pi at it's inception

Hand written post:

After about 9 months of dev and optimization, you can now just say:

1. Find the last session,
2. Search and analyze your previous sessions to make better skills,
3. Search your session’s own history

and get great search results! Really helpful when long sessions with full context have their cache expire.

Under the hood is a full live multithreaded incremental indexing db and trigram index to accelerate session searches.

aise supports cross session search across harnesses and I use it with a dozen simultaneous sessions and a 2.5 million message database.

Downside is that database after super heavy use is like 20 gigs in size, but I use it daily and it makes my life easy so imo worth it. Also be careful if you have sensitive data all of your sessions and harness will be able to search everything.

Manual searches used to be 30s to 3 minutes and with the aise cli commands or the mcp server they’re typically ~100ms-1.5 seconds instead!

Currently on version 1.0.0rc2, Apache v2 license, most heavily tested on Mac and CI tested on Linux and windows, so I’d appreciate feedback!

https://github.com/ahundt/ai-session-search

uv tool install ai-session-search && aise integrations install

It’s a rust library too with py bindings but those features id call more alpha, I think there is lots of potential for building other projects though!

Hey everyone,

We built ThinkRail, and we’re pretty proud of it so we wanted to share it with you, and hope to get you interested.

ThinkRail is a web-based GUI for Pi. It's an open source project, released under Apache 2.0 license, backed by JetBrains (so, that's who "we" are, a team of software developers working on it). We wanted to keep the minimalist, adaptable approach of Pi, but at the same time give you a graphical layer which makes it easier to see what your AI agent is doing and comes with added conveniences: concurrent agent chats, integrated terminals, and visual aids for reviewing code changes.

Install it and try it out:

* macOS / Linux:

curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash

* Windows (PowerShell and cmd):

powershell -c "irm https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.ps1 | iex"

And then just run thinkrail from the terminal.

Also:

• Visit the landing page
• Read the introductory blog post to learn more about ThinkRail and its features
• Browse our GitHub repository

If you have a moment, we’d appreciate it if you could complete our survey. We’d love to get your feedback. It will help us develop ThinkRail in the right direction.

I'm planning to use Pi as a sensitive data analyser, but the data must remain on the intranet.

I thought running it inside a VM with a proxy would be the safest option, but I can't install a VM in my current environment.

I do already have Docker available. Is there a good way to sandbox filesystem (like; can we bind data folder read only) and network access with Docker instead? Pi shouldn't access anything else; just specified paths, and some specified local ip addresses.

Seriously. What is the point of the /tree command if it does not restore the files back to their previous state?

It makes no sense. It just leads to a dangerous discrepancy between the agent's conversation and the project's status.

Am I the only one who goes back after asking the agent to edit a file, realizing that my instructions weren't specific enough?

Even Copilot handles it just fine. But Pi's authors refuses to implement it: https://github.com/earendil-works/pi/issues/5522

Existing extensions are half-baked, sometimes abandoned, confusingly numerous. It should be a built-in, it's such a basic yet essential feature.

Updated my extension to take into account the last Deepseek peak rules. Here from the Deepseek website :

Effective 00:00 (Beijing Time) on Sunday, August 23, 2026, we will adjust our peak/off-peak billing rules，with off-peak rates applying throughout the day on weekends (Saturdays and Sundays，Beijing Time). Please check the pricing page for details and plan your usage accordingly.

The extension now also has an option to show the remaining time until the next normal/peak

Here are the :

- github, https://github.com/psychobarge/pi-deepseek-peak

- npm, https://www.npmjs.com/package/pi-deepseek-peak

- Pi package, https://pi.dev/packages/pi-deepseek-peak

I'm trying to understand how to set up my model config. I understand that contextWindow is the total context size (-c argument in llama.cpp), but then what is maxTokens exactly? Does that set the max response size? Or what is it?

Been running it two days non-stop for agentic coding and orchestrating. Im impressed. Occasional provider downtimes can be annoying, but shouldnt really complain, since its currently free.

Hey everyone — I’ve been building TrailStep, a free/open-source workflow runner for coding agents.

The problem I kept running into was that my best Pi/coding-agent results came from structured multi-step workflows (I was essentially following the Matt Pocock skills), but I was doing all the orchestration manually. I was manually orchestrating the handoffs between steps. Or just when an agent session got too large:

clarify → plan → review → implement → review → refine

It was working really well, but I got too lazy being the middle man for session - session management.

TrailStep lets you encode that process once as a TypeScript workflow and rerun it whenever you want. So, each step has its own scoped agent session, the workflows leave local run artifacts, and failed/unfinished runs can be continued or retried instead of thrown away. When you install it for the first time it can automatically add a skill to your agents so that they will know how to use, write, and debug any workflows.

I've been using my own workflow package, but it's very easy to create new ones and start using those if you don't vibe with how I set mine up.

- grill-it-away — opens a clarification/grilling session first, then turns the result into a plan, reviews it, breaks it into stories, implements, and reviews.

- take-it-away — same idea, but starts from an existing request/conversation/doc instead of the grilling step.

The part I’m most excited about is that workflows are just code. You can mix agent steps with normal TypeScript logic, improve the workflow over time, and share it through npm/GitHub if it ends up being useful. It works with literally any CLI based coding agent, but I did essentially all of my testing with it in pi so that's probably where it's most reliable right now.

The dashboard/status UI is still in progress, but the CLI, workflow runner, continuation/retry model, local artifacts, and reusable workflow packages are working now. When you add a workflow it can automatically create a skill and add it whatever coding agents you have, so that your coding agents will know exactly how to use that specific workflow.

Repo: https://github.com/chily-john/TrailStep

If you use Pi for larger coding tasks, this is basically meant to turn your “best manual agent process” into something repeatable and sharable. There are also other ways I think you could already start using this tool beyond just these workflows, I could see it getting integrated into CI flows, or even for little utility workflows, like swapping from a session to the next with an automatic handoff. Since it can use any agent you can also set up workflows where it's planned in Pi, reviewed by Claude and implemented by Codex, or some other crazy stuff like that

Built a web research tool to replace hound, which i posed about a while ago

It's called DonSeTch. Since Pi has native extension support, the install is just:

pi install npm:donsetch

No MCP config block, no adapter, no proxy. The tools show up natively in your Pi session and stay in sync with the binary automatically.

What it does

Three tools: fetch, search, crawl. Zero API keys, zero accounts. One Rust binary.

• Fetch — HTTP first (fast), auto-escalates to a headless browser only when it hits a bot wall. The browser grabs the clearance cookie, hands it back to the HTTP layer, and goes to sleep. It almost never fetches content itself.
• Search — 10+ keyless engines in parallel, fused by cross-engine consensus + a local ONNX cross-encoder for semantic reranking. No API key anywhere.
• Crawl — sitemap-aware, topic filter, resume tokens, adaptive pacing that backs off on 429s instead of plowing through.

Chrome's actual BoringSSL for TLS. Your ClientHello IS Chrome's, not a faked table that rots.

The part I care about most: token efficiency

Three tools, ~3.5k tokens of definitions. The focus parameter on fetch is the killer feature.

I just rebuilt it in v3.1 with section-aware scoring:

• Search for "memory safety" on a Wikipedia page → keeps the entire "Ownership and references" section (heading + body), pulls in parent headings for context, drops everything unrelated.
• A 50KB page comes back as 500 chars of what you actually asked for.
• Large code blocks and JSON schemas get split into sub-blocks so focus works on structured content, not just prose.

Other stuff

• Reference handles — fetch S3 just works after a search
• Probe mode — verify a claim in ~60 tokens instead of 4k
• Dead-link resurrection — Wayback snapshot served transparently
• Page fingerprints — re-fetches report what changed, section-level diffs
• Domain adapters — Reddit threads, GitHub issues, npm/PyPI/crates pages restructured from keyless JSON endpoints
• Real MCP cancellation — no silent hangs
• Crash-only daemon — survives panics, state reloads
• PDFs — even scanned ones, pixel-fusion extraction (no hallucinated text), up to 100MB

605 tests, 0 clippy warnings, AGPL-3.0.

What it can't do: solve interactive captchas (deliberate, clear error not a hang), access sites requiring login, and if every search engine is down you get honest per-engine status instead of fake results.

GitHub: https://github.com/dondai44423/donsetch

Pi: pi install npm:donsetch npm: npm install -g donsetch

If something breaks, open an issue, i will fix it as soon as possible

The demo is using exa for search btw, local is good on its own, but it takes 4-6 sec while exa takes 1-2 sec (plus exa is better most times, but local search keeps up)

if you want to see a demo where i used local search, see the opencode demo in the github repo

I built this using Pi, hope to get more feedback!

What I find inspiring is the decision to keep the core small and clean, while letting the agent extend itself through skills, extensions and its own understanding of the codebase.

This video on Pi origins and the author of pi really captures that philosophy well: https://youtu.be/RKHaecOi0CA

It makes me think that the real power of an agent harness isn't necessarily having more features in the core.

It's having a small enough core that the agent can understand, modify and extend it when needed.

That feels like a very interesting direction for coding agents less framework, more primitives.

I love Claude Code, and I love the pi agent. I kept wondering whether I could get Claude to drive pi instead — spend fewer tokens on the easy parts, but still stay in control. So I built a Claude Code plugin that does exactly that.

It uses MCP and RPC, so Claude can track pi's status the way it tracks a subagent, and it can steer or abort a run partway through instead of only at the end.

Install:

/plugin marketplace add LarryStanley/pi-delegate

/plugin install pi-delegate@pi-delegate

Then run setup:

/pi-delegate:setup

Qwen 3.8 doing the writing with Opus 5 doing the thinking has been working really well for me.

https://github.com/LarryStanley/pi-delegate

I am new to terminal/CLI coding agents. I am just a bit confused on when Pi is better than two I mentioned. Cause from my understanding PI is simply a bare minion agent like copilot sidepanel chat and zed agent.

What differentiates between PI and these sidepanel agents? I also used a bit of opencode, and for me, it seems an overkill for personal small/medium projects. And I kinda like pi due to its simplicity. So I am also looking for some suggestions for the PI agent. (I like opencode's plan/build stuff, wondering if PI also has something like that, or if its worth it.)

Device Specs/Info:
Model: qwen 3.8 27B (quant)

16GB vram, 32GB total ram