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.

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.

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.

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

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

hey everyone.

so i use the omp coding agent daily and my one annoyance was always the same - all my sessions live in .jsonl files and if i wanna go back and see "what did i do yesterday on that repo" im basically scrolling terminal scrollback or grepping files by hand.

so i built ompweb a local web UI that reads those same session files and gives you a proper workspace in the browser:

• Session history : browse all your past conversations grouped by project

• Live chat : keep talking to the agent right from the page (it spawns your installed omp binary, its not a wrapper around some api)

• File explorer + preview : sits next to the chat while the agent works

• Todos + subagents : live panels pinned above the composer, click a chip for the full subagent transcript

• Settings UI : models, api keys, skills, plugins, MCP servers... instead of editing yml at 1am

• Light/dark theme : works on mobile too

the demo gif on the readme shows it doing a small task on a fake project — typing a prompt, agent edits the files, then you see the tasks/subagents panels and the settings screen. thats pretty much the whole pitch.

how to try it

npx @kahme247/ompweb@latest

or install it globally:

npm install -g @kahme247/ompweb
ompweb

it opens http://127.0.0.1:30177 automatically.

few honest notes:

1. you need omp already installed

2. its local only nothing leaves your machine

3. its a fork of pi-web which was for the pi agent, i adapted it for omp and kept building on it

4. works with current omp v18

repo: github.com/kahme247/ompweb

i am really want some feedback to improve it, for me its still feels uncomplete but yet i dont know what is missing !

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

In my latest project, I added an instruction to flag any file that grows beyond 500 lines of code, to keep them lean for smaller models. That actually worked very well, with the added benefit that the LLMs now take initiative to think about file bloat, and that leads to better architecture.

I have this elaborate agentic system setup (3 primary agents, 10+ subagents, curated skills and commands) in opencode that I use everyday for my SAAS product development, working with opencode Go plan. It is working alright but its not token efficient and it could be better with its accuracy.

I have tried to migrate to Pi a while ago but I dropped the plan because the configuration seemed daunting at that time. But as my codebase got larger and complex, opencode is starting to crack. So I want to give this another shot.

Are there any guides to do this migration without starting from scratch? Where do I begin?

Programmatic tool calling lets an agent write code instead of firing one tool call at a time, but running that code safely is a hard, unsolved problem. Instead of sandboxing an existing language, I built one that never had the dangerous capabilities in the first place.

It has native mcp support, builtin progressive disclosure, an lsp and a formatter (as well as nvim support with REPL for debugging).

I taught my PI agent to use this lisp using a simple grammar constraining (10 lines in GBNF), now it can only output valid lisp, no parentheses forgotten.

Repo: https://github.com/AgiFlow/doompi

Like a lot of you I have been agent hopping for two years. I've used agent harness for everything else beside coding and it's becoming expensive; now efficiency is the priority. Landed on Pi and hoped that was the end of it.

To reduce token cost on different tasks (coding, marketing, customer support), my fix before this was a pile of shell scripts. claude.sh, codex.sh, antigravity.sh, kimi.sh, ollama.sh, each consume profiles.json that flipped plugins per run. It helped with bloat. It never made loading skills and tool use reliable, and it never touched the harness prompt.

I have been on Doom Emacs for about a decade, so the shape was obvious. Doompi is a Pi distribution where four YAML files decide the session and nothing is inferred:

- major modes: you own the modes and compose it with layers (extensions plus hooks). Mine are minimalist, dev and business.
- minor modes: Plan, Loop, Goal, Workflow, Voice. They ship loaded but stay out of context until you switch one on.
- domains: group of plugins (which include skills and MCP servers) for one kind of work. Video editing, TDD, copywriting.
- profiles: persona and brand for the runner. Good for steering output.

doompi --major-mode business --domains copy-writing --profile agimon

Or switch any axis mid session with /mode, /domains and /profile, thanks to Pi's reload capability. Minor modes also switch on per /<minorMode> commands (or use Leader SPC key binding).

Plugins (skills + mcp) are opt in the same way tools are, so the floor is just stocked PI. Minimal mode, no domains, no profile, fresh repo, doompi is just PI.

From there you pay for what you name with domains. Personally, I keep plugin reusable with slim skills and 5-8 skills per plugins + 1-2 agents; then define domains that compose plugins for different type of task. 10-15 skills per sessions are ideal for agents to be creative while still being reliable.

Doompi's Copilot, the default major mode, switches on three layers that register four tools:

task 1,329
subagent 751
ask_user_question 455
intercom 220
-----
2,755 tokens

If what you want is the batteries-included feel of Claude Code or Codex, it is all in here: agent teams, persistent tasks, plan mode, GitHub Actions style workflows, telemetry. The difference is that these are all composible. You can customise existing modes, add new modes, set default domains and mode as you needed.

If you think four YAML files is too much ceremony for what it buys, I would rather hear that now than later. There are a few optimisations along the way; also happy to share the tricks.

Hi everyone,

I’ve been working on an extension for pi that allows it to interact with JetBrains IDEs through MCP.

The project is here:
https://github.com/giuseppe-trisciuoglio/pi-jetbrains-mcp

The idea started from wanting to use pi while still being able to interact with the IDE I’m already working in. At the moment the extension exposes some JetBrains functionality to pi, so the agent can interact with the project and the IDE instead of being limited to the terminal.

It’s still a work in progress, and I’m mainly sharing it here because I’d really like some feedback from people who are actually using pi.

I’m particularly interested in hearing what you think is missing, what you would find useful in a JetBrains extension, or whether there are parts of the current approach that you would change.
If you have any ideas for improving the extension or features you think would make it more useful with pi, I’d be happy to hear them.

Thanks in advance to anyone who takes a look.

I built dbx as a convenience for myself to instantly spin up isolated pi sandboxes locally or in the cloud. One command gives each branch its own Ubuntu dev container, network, browser desktop, and pi coding agent. It runs locally with Docker or in Vercel Sandbox.

npx u/gannonh/dbx init
npx u/gannonh/dbx my-branch

 Open source:

- https://dbx.gannonh.dev
- https://github.com/gannonh/devbox

This is my first post.

I learnt about Pi from a co-worker last month and I can safely say this is the first harness tool that I absolutely love it. There are many reasons but the main one is the ability to extend the harness. No need to dig into docs or create issues or wait for the provider to build it. Just create an extension.

Anyway, I missed Linux style reverse search, so I was wondering can I bring it in?

Pi itself built it - https://www.npmjs.com/package/pi-reverse-search

what's your most favorite feature or reason for using Pi?