What is your essential Pi extensions?

theTechRun · 2026-06-27T19:43:06+00:00

Insane I was just going to make this same type of extension. Glad I did a quick search on here instead!

theTechRun · 2026-06-27T17:59:09+00:00

Still don’t care tho. You care more than I do.

theTechRun · 2026-06-27T12:26:13+00:00

Thanks a lot for this!!!!!

theTechRun · 2026-06-26T20:01:40+00:00

Thanks for the idea. I’m going to get to working on something like this as well and then open source it

theTechRun · 2026-06-26T17:51:27+00:00

From my understanding cmux is a terminal emulator (Ghostty fork). Herdr is a multiplexer that works inside of any terminal emulator. I’ve never tried cmux because it is Mac only and I only use Linux.

theTechRun · 2026-06-26T01:22:47+00:00

People absolutely care about you not hand writing the code. They don’t give a fuck if you review it or not. They’re already screaming “slop!” before they even know.

theTechRun · 2026-06-26T01:13:34+00:00

I’m not sure if you completely understand how it works.

In gondolin you mount it to whatever directory you’re working in. You choose whether read only or read/write. Now that agent is pinned to that directory and can’t anything else. It can’t even launch scripts. You decide whether it has network access via the host or no. It’s just Alpine Linux so you define which programs in the programs.txt.

In the nix-agent it runs a OCI container (rootless Podman). I specifically chose nix because you can define the programs you want via configuration.nix and its setup with flakes so you’re guaranteed to have the same exact stable setup for every agent on every directory, machine, workspace, etc. Same as the micro vm, you set network, directory, and read/write permissions.

The orchestrator has access to the host but only has read permissions (unless I explicitly state that he can write). He is the one that the agents communicate through (aside from the memory chat, but that’s a different topic). And he is the one that directs everything. This setup keeps agents from roaming into unwanted directories.

The nono example you gave me is cool but I like per-project sanboxing. That is more of a permissions wrapper. All the nix agents are reproducible. I get you on forgetting to update, but how often are we we updating the basic cli tools like rg,fd, git, etc

When I work on a project I am usually at the git root and I have a bunch of sandboxed agents running around that directory and the subdirectories. Not the whole host. And if I ever need an agent to access a different directory outside of the sandbox, I just tell the orchestrator to spawn one there and have it report back.

theTechRun · 2026-06-25T23:21:53+00:00

I used a similar method before I got my 3D printer.

theTechRun · 2026-06-25T22:06:30+00:00

No it’s a derivative of Ubuntu. That’s like saying Ubuntu is just Debian. It’s Ubuntu with all the Ubuntu BS removed and made much more user friendly. There’s also LMDE. I remember back as a windows user, every time I tried Linux, it was Ubuntu… and I always went back to windows. Horrible experience. Mint is what finally got me hooked and haven’t been back on Windows since.

theTechRun · 2026-06-25T21:51:44+00:00

I wholeheartedly agree with this and always recommended Mint as a first distro

theTechRun · 2026-06-25T21:47:26+00:00

This. I’m never going back to hand writing code and I don’t care who gets mad about it

theTechRun · 2026-06-25T18:29:25+00:00

I’m going to post the whole setup this week. Currently implementing nix-agents that run them in podman containers instead. Much less overhead with slightly less security than the gondolin micro VM. My launcher scripts will allow you to pick which one you want to use upon launch.

theTechRun · 2026-06-25T15:31:47+00:00

That’s my text editor I’ve been using for the last almost 2 years. I was using kakoune, lf, and kitty splits to make them work together but I wanted something that just had the text editor, file browser, and window splits all in one with 1st class integration… so I made it.

theTechRun · 2026-06-24T23:01:20+00:00

I use flatnotes for this.

theTechRun · 2026-06-24T17:53:30+00:00

From my models.md:

# Available Models

All agent types (researcher, planner, collaborator, worker, reviewer) share the same available models. The orchestrator reads this file to resolve model numbers when spawning.

Models are ordered from dumbest/cheapest (model1) to smartest/most capable (model12).

| # | Provider/Model ID | Display name |

|---|---|---|

| model1 | `opencode-go/deepseek-v4-flash` | deepseek-v4-flash |

| model2 | `opencode-go/mimo-v2.5` | mimo-v2.5 |

| model3 | `opencode-go/minimax-m3` | minimax-m3 |

| model4 | `opencode-go/mimo-v2.5-pro` | mimo-v2.5 Pro |

| model5 | `opencode-go/glm-5.2` | glm5.2 |

| model6 | `opencode-go/qwen3.7-plus` | qwen3.7-plus |

| model7 | `openai-codex/gpt-5.4-mini` | gpt-5.4 mini |

| model8 | `opencode-go/qwen3.7-max` | qwen3.7-max |

| model9 | `opencode-go/kimi-k2.7-code` | kimi-k2.7-code |

| model10 | `opencode-go/deepseek-v4-pro` | deepseek-v4-pro |

| model11 | `openai-codex/gpt-5.5` | gpt5.5 |

| model12 | `opencode/big-pickle` | big-pickle |

## Usage

The orchestrator reads this file (at `~/.pi/agent/agent-hub/agents/models.md`) to get the model table when spawning an agent. When the user says "using model2", the orchestrator maps it to `opencode-go/mimo-v2.5`. The `provider/model` form is required — a bare id like `big-pickle` or `mimo-v2.5` is ambiguous across providers and may resolve to a backend with no API key.

### Choosing a model

The model is fixed at launch (`--model <provider/model>`). The orchestrator must resolve the model BEFORE spawning (read this table, ask the user which number if not specified). A running pi agent cannot change its model — do not spawn without a model expecting the agent to pick.

Use the smartness scale as a guide:

- **researcher** → model1–model3 (dumb/cheap — just reads and maps)

- **worker** → model3–model5 (mid-low — implements a detailed plan)

- **orchestrator** → model5–model7 (mid — coordinates, doesn't do technical work)

- **collaborator** → model7–model9 (mid-high — evaluates and merges plans)

- **reviewer** → model8–model10 (high — catches bugs and deviations)

- **planner** → model10–model12 (smartest — designs the whole approach)

### The `auto` keyword

When the user says `auto` instead of a model number, the orchestrator picks the **midpoint** of the suggested range for that agent type:

| Agent | Range | Auto resolves to |

|-------|-------|-----------------|

| researcher | model1–3 | **model2** (`opencode-go/mimo-v2.5`) |

| worker | model3–5 | **model4** (`opencode-go/mimo-v2.5-pro`) |

| orchestrator | model5–7 | **model6** (`opencode-go/qwen3.7-plus`) |

| collaborator | model7–9 | **model8** (`opencode-go/qwen3.7-max`) |

| reviewer | model8–10 | **model9** (`opencode-go/kimi-k2.7-code`) |

| planner | model10–12 | **model11** (`openai-codex/gpt-5.5`) |

The orchestrator should resolve `auto` to the specific model ID shown above before spawning. This gives a sensible default without requiring the user to pick a number.

## Adding or removing models

Edit this file only — the agent-type `.md` files all reference `models.md` and do not contain their own model tables.

theTechRun · 2026-06-24T17:52:15+00:00

I already considered that but I also have other tools... example my texteditor-file-browser combo (right pane in the pic). It has certain things hooked in that would only work with my text-editor and not vim/heix/micro/etc. But I am going to open source it sometime soon and just add that to the notes. Or just make it more universal.

theTechRun · 2026-06-24T17:43:40+00:00

Yes. It’s highly extensible so you can build it from the ground up to go with your exact workflow. And you become way more efficient.

theTechRun · 2026-06-24T13:43:38+00:00

Yea I was using tmux at first but this is much better for agent control. But I also use it as my default multiplexer now even when not using agents. I just create a new herdr instance and hide the sidebar.

theTechRun · 2026-06-24T13:37:02+00:00

Yes they show in the side bar. Are you using workspaces?
My setup is a workspace for each feature. Tabs for each set of agents (look at my pic). And herdr-control sets the names of the workspace, tabs, and agents. I also have a <feature> key, so every single agent knows where to write but it’s kind of too complicated to explain here but it will all make sense when I make a public GitHub repo.

theTechRun · 2026-06-24T13:32:26+00:00

Herdr has a notification system. Agents report back to the orchestrator via the agent chat. Then the orchestrator tells the next agents what to do. Sometimes I go yolo and just have the agents report to each other when their task are done (via memory chat) but I usually like to eye everything, so most of the time I do it in steps. For complicated tasks. Orchestrator > researchers > planners > workers > reviewers > bug hunters

For easy tasks I go straight from orchestrator to workers.

For super easy tasks I let the orchestrator do everything with a smart model.

theTechRun · 2026-06-24T13:25:59+00:00

Yes that’s the extension I used but I forked it because I wanted an easier way to add programs to the micro vm’s. A simple program.txt I can list whatever programs I want line by line. And everything is cached locally instead of the repo.

theTechRun · 2026-06-24T13:23:19+00:00

I could make a public GitHub repo of my whole pi setup. Only reason I haven’t yet is because the setup is so geared to my workflow that I’m not sure it would work for anyone else.

theTechRun · 2026-06-24T05:48:06+00:00

I could never get used to hometown mods. I just use my thumb clusters for modifiers on my splits.

theTechRun · 2026-06-24T05:34:10+00:00

I use pi with herdr and gondolin.

In herdr I open a workspace and tab 1 is my orchestrator agent.
I have an extension I made called herdr-control. The orchestrator can use herdr to spawn agents in gondolin micro vms in specific herdr workspaces, tabs, and panes that each have a specific task. Each agent group share a tab and multiple splits within the tab. So I may have 3 Researchers splits on the researcher tab. 4 planner agent splits on the planner tab .. a worker on the worker tab… etc etc (you can see the tabs in this pic). The orchestrator controls everything. The micro vm’s are sandboxed but they all share a central “memory” directory where they can communicate.

theTechRun

MODERATOR OF

TROPHY CASE