Join the discussion

Write your take first — we'll ask for email only when you're ready to publish.

  • Hacker News
  • I am starting to share the opinion in the article. I used to use Claude Code with strong open models, and sometimes pay for Opus.

    Now one of my main drivers is out of the box pi’s 4 built in tools, and I add just two extra tools: pi-sandbox and a paid for search service tool. This setup works great with the latest deepseek v4 flash, switching to more powerful open models occasionally.

    I wrote my own coding harness in Common Lisp that is almost free or 3rd party libraries and I basically copied pi + the 6 tools I use for pi (except I have two search tools using different vendors in my Common Lisp code).

    Everyone (and every company?) should run their own tests and experiments. I find it sad when I talk with people who default to the most complex and the most expensive tools without even trying to evaluate alternatives.

  • Love pi. It's good to have a minimal agent, always welcome. Even if only to bootstrap install other agents. E.g. recently Hermes stopped installing under Termux (v0.19 - no, v0.18 - yes). Agent pi to the rescue: installed it under Termux (Android), started it, pointed pi to the Hermes github, asked for v0.18 specifically - and it did it. Cherry on the top - asked it to install a plugin from github I use (unmerged PR), did that too. Even if nowadays for coding I mostly use OMP (the pi with wheels and bells and whistles). For general computer use mostly use Hermes. Model-tied harnesses have their place e.g. Codex for me. I never know if it's allowed or banned using the sub from non-Codex harness - so stick with it. Even if only to have the 'canonical reference setup' to compare with and measure against.
  • I often find it reductive when people say "just tell Pi to build you an extension". Having used it as my one and only harness for a few months now, it's easy to get an extension, but hard to get a good one, that actually works well and helps.

    My advice: focus on getting work done and slowly adapt Pi with small augmentations as you go. You can start getting work done on vanilla setup. When the right idea comes along, try it. Be ready to refine it, and most importantly, rollback the addition. I've rolled back a bunch.

    Many "batteries" that are "included" come from speculative and half-baked ideas, from people who were excited about something at some point in their journey. In practice, those ideas may not bring the desired results, and their creator may've moved on already. So it's better to either learn very well established tools, or mold your own slowly.

    For example, many automatic memory systems are not helpful. I built a small extension that asked me whether it should remember something (and write it down to a properly scoped SKILL or AGENTS file). Turned out I accepted less than 5% of suggestions. Most were useless one-offs that would pollute the context. Can't imagine how much crap would accumulate if I wasn't in the loop.

  • skills as memory is a great idea
  • I couldn't agree more.

    I think for indie hackers and people that build their own stack is great, but real scenario and people with money Enterprise likes the idea of batteries included.

    I found this one a little bit better and they do support Extensions like Pi. But comes with all features like codex, claude code and it's open-source.

    https://github.com/autohandai/code-cli

  • I have the same opinion as your first paragraph, but I don't want to spend weeks or months vibe-coding basic features which come built into almost every other agent.

    Yeah maybe Claude/OpenCode/KiloCode/Hermes/whatever are not as minimal as Pi but they also work right now.

  • Pi is really good. For people who want to build their own agent with even more minimal and extensible, the underlying agent harness is also worth looking: https://github.com/earendil-works/pi/tree/main/packages/agen...
  • I'm enjoying the maximal version: https://omp.sh
  • I find omp funny because it's the opposite of why Iike Pi.
  • OMP is great to get started with, there's a whole bunch of stuff in there but it's mostly optional and turned off by default (like the memory backend). You can always try it and create a custom Pi config with only the stuff that you find useful if it's too much.

    I'm really enjoying the advisor mode (you can have a second model monitor the output of the primary model and have it "steer" the primary when it makes a mistake or goes off the rails) and the automatic fallback to a second provider if the primary one has issues (Deepseek had some issues yesterday).

    I need to dive a bit into the system prompt to see how much context OMP actually adds. I think the system prompt is still 2-3k tokens but that probably depends on bells and whistles.

  • OMP is great. I pair it with https://nono.sh/ and sleep alot easier at night.
  • Both Codex and Claude have trained their models to their harnesses.

    There are some experimentations by Igor Warzocha to extract Codex shapes and put it in Pi: https://github.com/IgorWarzocha/howaboua-pi-stuff/tree/main/...

    I'm expecting every model will have a fine tuned Pi extension at some point.

  • in my experience pi does much better than codex for compaction and token use. And this is the main reason I switched to it.

    migrating to the same compaction and exact tools as codex uses will make it at the same level as codex so what benefit will it have over codex? sure you can customize tui to your liking and add something on top, but the efficiency gains will be gone

  • I’ve been using both families of models inside pi/piclaw (https://rcarmo.github.io/projects/piclaw/) and I assure you they work _better_ in that environment than in the originals. The models are not trained to the harnesses, the harnesses provide cues that the models follow.
  • Aside from the minimal system prompt, how does it handle context better than other agents? It still has to send the system prompt (which includes AGENTS.md and skill definitions) along with the full conversation every request, no?
  • It doesn't do anything unique WRT context management. It's just much less opinionated.
  • It's really just the minimal prompt and the minimal built-in skills. And ~full control I guess if you wire up something custom (I haven't).
  • the compaction does not compact whole context, but keeps last ~20k tokens as is, I believe this helps a lot to model to not get confused what it is doing right now.

    it also have soft/soft compaction limit, it tries to compact on turn boundary when possible. with combining with above this can get you about 35% more context (at least it looks like this with the sol)

    codex when shell command is executed, will pull output with hard cap at max 30s, so for running compilation it will burn tokens without any benefit.

    I have some tasks where agent will have to run some suite that can take over an hour, and codex burns about $20/h just waiting and reasoning every 30s "yep, that's still running". And what is going to happen after compaction, when whole context was just waiting? it will loose the plot and when I'm back it just does completely different thing that I asked it to do.

    codex also have a bug, that opening refuses to resolve that adds your last steer after compaction, so imagine that you asked it to cleanup some tmp files or refactor/simplify something. it will do that again and again after each compaction, best case it just burns tokens and figures out, this is already done, or worse do it again and mess up everything and forget about it's task

  • A lot of harnesses compress the context when it becomes massive, Pi doesn't do that out of the box (EDIT: that's wrong, as pointed out below). It can be both good and bad. Also since it doesn't have a lot of tools out of the box, the context is not polluted with external tool call descriptions that the agent has to be aware of.

    Basically, it doesn't handle the context "better", it barely does anything special to it, which can actually be better for cost efficiency.

  • a few examples:

    1) system prompt in pi is quite small (way smaller than the one from OpenCode)

    2) when your agents.md file changes pi does not re-spam it (preserves cache, good trade-off!)

    3) only 4 tools, every tool comes with a description for how to use it and causes reasoning overhead (fewer tools is good)

    all of these things add up

    here are pi, opencode and smol working on the same tasks in 9 fresh runs

    https://smolenv.com/t/nested-template-includes-60636/

    you can step through the traces and see how the system prompt + tools steer the agent in a certain way

    with GPT 5.6 Sol you can even get away without a system prompt (see smol) and only 1 tool (sh)

    by tosh
  • The /tree feature is incredible for context management. It's really surprising the other harnesses haven't slurped it up yet. It lets you rewind back to any previous message and fork the conversation from there, removing your 'side quest' (e.g. where you dig into something the agent said) from the context. Some other harnesses have a 'rewind' feature, but this lets you maintain the previous conversation history in a separate thread, and even jump between them.
  • Pi does one thing that I love, developing a tool that has minimalism where it's easily configurable with good documentation. The leads to new use cases that the the author(s) would have never dreamed of. The organic growth process of the Pi ecosystem has been fascinating to observe. It's one of the reasons why Pi has become one of my favorite coding agents to this day, flexible beyond personal uses and extensible to larger environments.

    IMO, I view it more than a coding agent, it's a coding agent platform with powerful extensibility.

  • I’m going to go against the grain and say that Pi is a little too minimal by default. The emacs comparison is interesting, but default Pi is like emacs that can load files but you’ve got to extend it manually to save or search within a file.

    I’d argue that there’s a minimal set of functions that a coding harness needs to just enable a model to get stuff done, and they shouldn’t be an extra effort to set up.

    (Oh-my-pi exists for those of a similar persuasion.)

    by mft_
  • What is that set of functions for you?
  • Having tried all the coding harnesses, I find that using Pi is exactly like using Emacs. For anything you want to build you can ask your agent and it will build it. There's tons of existing code to help you configure it. At the same time half the code is buggy, UI elements will try to overlap one another, and you'll periodically get crashes.

    If you're willing to put in the work to master the learning curve and push through the issues, it can be a great tool: https://i.sstatic.net/7Cu9Z.jpg

  • If you like Emacs, why not make Emacs your harness?

    https://github.com/karthink/gptel

  • Never learned Emacs but am a Neovim user. But similar to what I said to my colleagues as well. Codex, Claude Code are VS Code, Jetbrain. Pi is Neovim.
  • I don't really get this philosophy, at least with coding harnesses.

    I don't want to spend 2 hours prompting, configuring and fixing features that I need which are standard in every other harness. I don't really want to be wasting my tokens to make an application function like every other harness. I don't really want to have to repeat the cycle on every machine I want to work with. Every VM, every server, every laptop.

  • I've had a lot of success running Pi on my server in headless mode and wrapping it in an XMPP client. This means I can talk to it wherever I can access XMPP (everywhere). It also mean agents can talk to each other when they need to. They've got a shared wiki they interact with and github issues as their todo list.

    I am running several named pi instances in parallel in their own user account on NixOS, so they can install whatever they want in ephemeral shells and I never need to worry about their env. The agents can spin up new enabled XMPP agents if I request it, though for now I've only needed a few since I'm not doing too much in parallel.

    My Pi is very vanilla, only my own XMPP wrapper and pi-subagents extension for anonymous subagents.

    Using it primarily with Deepseek v4 Flash for chipping away at coding tasks or server maintainence while I'm AFK or in transit.

    NixOS is the key to all of this, since agents can interact see the whole server config, make changes and run compile-time checks before actually deploying. It also means that even if they do mess up I can always revert.

  • at this point, what's the advantage of this setup vs something like hermes?