Pass for me.

Where did you get this perspective from?

> I thought pi and its tools were supposed to be minimal and extensible. So why is a subagent extension bundling six agents I never asked for that I can’t disable or remove?

Why do you think a random subagents extension is under the same philosophy as pi?

Your blog post says little about pi proper, it's essentially concerned with issues you had with the ecosystem of extensions, often made by random people who either do or do not get the philosophy? Why would that be up to pi to enforce?

Pi ships with docs that include extensions and the agent looks there for inspiration if you ask it to build a custom extension.

Looking at what others publish is useful!

This is quite nice — I do think there’s a version of pi’s design choices which could live in a static harness, but fully covering the same capabilities as pi without a dynamic language would be difficult. (You could imagine specifying a programmable UI, etc — various ways to extend the behavior of the system, and you’d like end up with an interpreter in the harness)

At least, you’d like to have a way to hot reload code (Elixir / Erlang could be interesting)

This is my intuition, at least.

I'm super on board the rust train right now & super loving it. But no, code hot loading is not common.

Most code in the world is dead code. Most languages are for dead code. It's sad. Stop writing dead code (2022) was no where near the first, is decades and decades late in calling this out, but still a good one. https://jackrusher.com/strange-loop-2022/

But Rust can dynamically link with dylib but I believe it's still unstable.

It can also dynamically load with libloading.

No serialization/JSON-RPC layer between a TS CLI and Elixir server. TS TUI libraries utilities are really nice (I rewrote the Elixir-based CLI prototype as it was slowing me down). Easy to extend with custom tools without having to write them in Elixir, which can be intimidating.

But you're right that Erlang's computing vision lends itself super well to this problem space.

[1]: https://github.com/matteing/opal

The first issue I had was to figure out the schema of the models.json, as someone who hadn't used the original pi before. Then I noticed the documented `/skill:` command doesn't exist. That's also hard to see because the slash menu is rendered off screen if the prompt is at the bottom of the terminal. And when I see it, the selected menu items always jumps back to the first line, but looks like he fixed that yesterday.

The tool output appears to mangle the transcript, and I can't even see the exact command it ran, only the output of the command. The README is overwhelmingly long and I don't understand what's important for me as a first time user and what isn't. Benchmarks and code internals aren't too terribly relevant to me at this point.

I looked at the original pi next and realized the config schema is subtly different (snake_case instead of camelCase). Since it was advertised as a port, I expected it to be a drop-in replacement, which is clearly not the case.

All in all it doesn't inspire confidence. Unfortunate.

Edit: The original pi also says that there is a `/skill` command, but then it is missing in the following table: https://github.com/badlogic/pi-mono/tree/main/packages/codin...

The `/skill` command also doesn't seem registered when I use pi. What is going on? How are people using this?

Edit2: Ah, they have to be placed in `~/.pi/agent/skills`, not `~/.pi/skills`, even though according to the docs, both should work: https://github.com/badlogic/pi-mono/tree/main/packages/codin...

This is exhausting.

It looks 100% vibe coded by someone who’s a complete neophyte.

Their agent mail was great & very early in agent orchestration. Code agent search is amazing & will tell you what's happening in every harness. Their Franktui is a ridiculously good rust tui. They have project after project after project after project and they are all so good.

Didn't know they had a rust Pi. Nice.

It’s clear it was 100% written by Claude using sub-agents which explains the many classes with 5000 lines of rust in a single file.

It’s a huge buggy mess which doesn’t run on my Mac.

If you’re a rust engineer and want a good laugh, go take a look at the agent.rs, auth.rs, or any of the core components.

Looks like a lot of nonsensical commits.

First of all it wouldn't build, I have to mess around with git sub-modules to get it building.

Then trying to use it. First of all the scrolling behavior is broken. You cannot scroll properly when there are lots of tool outputs, the window freezes. I also ended up with lots of weird UI bugs when trying to use slash commands. Sometimes they stop the window scrolling, sometimes the slash commands don't even show at all.

The general text output is flaky, how it shows results of tools, the formatting, the colors, whether it auto-scrolls or gets stuck is all very weird and broken.

You can easily force it into a broken state by just running lots of tool calls, then the UI just freezes up.

But just try it and see for yourself...

Don't hate me aha and no, there is no reason other than I can

So it can share code with the web app.

Because writing it in javascript is easier than writing it in raw brute forced assembly.

https://news.ycombinator.com/item?id=47120784

if agents continue to get better with RL, what is future proof about this environment or UI?

I think we all know that managing 5-10 agents ... is not pretty. Are we really landing good PRs with 100% cognitive focus from 5-10 agents? Chances are, I'm making mistakes (and I assume other humans are too)? Why not 1 agent managing 5-10 agents for you? And so on?

Most of the development loop is in bash ... so as long as agents get better at using bash (amongst other things), what happens to this in 6 months?

I don't think this is operating at a higher-level of abstraction if agents themselves can coordinate agents across worktrees, etc.

CLIs like claude code equally improve over time. tmux helps running remote sessions like there were local.

Why should we invest long time into your „ADE“, really?

> see their status and review / test their work

Won’t that be addressed eventually by the CLIs themselves?

Maybe you’re betting on being purchased by one of the agentic coding providers given your tool has long term value on its own?

It's a great idea: really neat take on programmability, and can be reloaded while the agent is running without tweaking the harness, etc -- lots of benefits.

`pi` has a great skills implementation too.

I think skills might really shine if you take a minimal approach to the system prompt (like `pi`) -- a lot of the times, if I want to orchestrate the agent in some complex behavior, I want to start fresh, and having it walk through a bunch of skills ... possibly the smaller the system prompt, the more likely the agent is to follow the skills without issue.

There is barely any magic in the harness, the magic is in the model.

Try it: write your own harness with (bash, read, write, edit) ... it's trivial to get a 99% version of (pick your favorite harness) -- minus the bells and whistles.

The "magic of the harness" comes from the fun auxiliary orchestration stuff - hard engineering for sure! - but seriously, the model is the key item.

It turns out that "most of the bell and whistles" could amount to instructing models how to use tools like tmux

This whole game is a bizarre battle.

In the future, many companies will have slightly different secret RL sauces. I'd want to use Gemini for documentation, Claude for design, Codex for planning, yada yada ... there will be no generalist take-all model, I just don't believe RL scaling works like that.

I'm not convinced that a single company can own the best performing model in all categories, I'm not even sure the economics make it feasible.

Good for us, of course.

And that’s out of the box. With how comically extensible pi is and how much control it gives you over every aspect of the pipeline, as soon as you start building extensions for your own, personal workflow, Claude Code legimitely feels like a trash app in comparison.

I don’t care what Anthropic does - I’ll keep using pi. If they think they need to ban me for that, then, oh well. I’ll just continue to keep using pi. Just no longer with Claude models.

Can you please share good resources I can learn from to extend pi?

You can just tell it to create an extension to connect to any AI API provider and it'll most likely one or two-shot it for you.

IMO it's the most self-aware of all of the current harnesses.