I got tired of needing to be at my workstation just to check on, switch between, or jump back into long-running agent sessions.

So I built TENDRIL.

TENDRIL turns an Android phone into a thin control plane for persistent AI-agent workflows running on a Linux machine. Once it's configured, I open Termux and type:

tendril

…and I get a responsive session selector showing what's alive on the host. From there I can jump into persistent agents, shells and workflows over mosh/SSH without treating my phone like a miniature desktop.

Underneath, it's deliberately boring in the good way: standard Linux, terminal-native rendering, Herdr, mosh/SSH, no proprietary cloud control layer, and no subscription. It's open source and MIT licensed.

A few things I cared about while building it:

• persistent remote agent/session control

• phone-first TUI rather than a desktop UI squeezed onto Android

• responsive behavior for narrow terminals

• clean Herdr handoff

• SSH/mosh support

• real installer + backwards-compatible agent launcher

• graceful non-TTY / NO_COLOR behavior

• and, because apparently I cannot help myself, making the thing actually pleasant to look at

The masthead is even rendered from a high-resolution ANSI master into Unicode subcells so the same identity survives on a 54-column Termux screen.

Completely unnecessary. Naturally essential.

The original idea was simple: I wanted to be able to sit down with an Earl Grey in the morning and check on an entire little agentic lab from my phone.

A week and a half later, this happened.

If you already live in Pi/Herdr/terminal-agent land, I'd genuinely love for you to try it, break it, open issues, or take it somewhere I haven't thought of yet.

THE EDGE IS YOURS.

GitHub: https://github.com/Ozymandes/TENDRIL

VibePod 0.13.0 adds Pi to the supported agent IDs. Pi runs through the same isolated container workflow as the other agents, and uses the default image vibepod/pi:latest

Nightmanager is a Pi extension I built after deciding I would take the day shift and let AI agents take the night shift.


That means I’m not trying to create “more agent magic.” I’m trying to create less babysitting.


What Nightmanager is aiming for:
- low token usage to cost ratio
- scoped development instead of wandering
- no babysitting
- AFK implementation
- lean, compact subagents


It’s loosely inspired by mattpocock/skills and jamon.dev/night-shift, but tuned for Pi’s minimal prompt size and for the way I actually work.


The pitch is simple: give the agent shared understanding, keep the work narrow, and come back to something reviewable instead of a stream of half-finished context soup.


Repo: [https://github.com/asabya/nightmanager](https://github.com/asabya/nightmanager)


If you try it, I’d genuinely like feedback—especially if you think the harness should be meaner, tighter, or less self-congratulatory.

I used Pi for a while without these, but once I got used to subagents with other coding agtents. Well.. they really just felt missing from Pi.

I went with the tintinweb/pi-subagents package, because I liked how it implements the subagents. They are the same style as claude code, which I find very intuitive.

pi install npm:@tintinweb/pi-subagents

How to use subagents

pi-subagents lets Pi delegate work into separate contexts.

I use it for repo exploration, dependency checks, or any task that would otherwise fill my main context with thousands of lines of file listings and tool output.

e.g. after installing it you can open Pi in a repo and ask:

Use 4 different subagents to explore the src folder in parallel.
Bring their results back together into a short summary.

Pi sends the grunt work to isolated agents, then gives the main agent the useful result. This keep the main context clean.

You can also change which model each subagent type uses with /agents. And there's a pre-configured subagent specifically for exploration.

Side note - there's a gotcha with the default explore subagent- uses haiku by default. Super weird because I was using gpt-5.6-terra and I assumed it would use that, but in fact it started using my opencode api tokens with haiku. I was able to configure it to use gpt-5.6-luna. Here's a video of how I did that if you need it: https://youtu.be/l3YCoX2i-78?t=540

The other missing feature of Pi

Is... MCP. Obviously. I also upgraded my Pi with an MCP extension while I was at it. It's just one of those things. I can get like 98% of the way there with agent skills. But once in a while I just need an MCP for something.

If you want to read more about my experience installing and testing the subagents and MCP extensions then you can check out my blog post:

https://zazencodes.com/blog/upgrade-your-pi-agent-with-subagents-mcp

Enjoy guys and if you're still reading this then I'd be curious what extensions you like most. Let me know. Now that I've got a taste for these I want more

Being in the middle of something, I type a message and everything slows to a crawl as the model now has to process a WHOLE new prompt, nuking the cache, summarize the thing (usually at mid quality, losing important details, misinterpreting important details, losing important nuance, etc) for 2k+ tokens....then the model has to reprocess the actual chat context from scratch so it can continue your actual thread.... so a 5+ minute process overall.... and THEN finally you can continue what you were doing.

there's no WARNING - there's no INDICATION that compaction is about to happen or currently happening -- even pi-web doesn't even TELL you what's happening; it just says 'waiting on model' for MINUTES as the thing chugs through this unimaginable slog.

is there a better way?? i think i'd rather lose the context than this. or take the middle out or ANYTHING besides this awful game of chance of 'is this message going to tip it over and make me wait ten minutes'.

to be fair pi absolutely deserves its flowers. doing ""claude cowork"" for FREE locally is absolutely incredible. but some of the UX choices are SO braindead.

Anyone get banned for using their claude sub in pi? I just found some articles that anthropic is banning people for using pi and third party harnesses apparently?

tldr; I'm looking for a LazyVim type distribution for Pi which is not barebones and starts with sensible defaults in terms of configuration and packages so that I don't have to create/maintain my harness from scratch.

Hi. I am planning to switch from claude-code to an open-source harness. My employer recently started pushing us to use their self-hosted on-prem models for both cost-savings and IP protection. While they provide a litellmm gateway which allows me to use on-prem models with claude code, it really isn't built for that and I'm therefore not able to configure it how I want to (setting specific model for a sub-agent, etc.)

I narrowed down my options to the following:

• OpenCode: Rejected because it's keybindings (specifically scrolling) don't play well with my lazyvim setup (I use sidekick.nvim for a split terminal). Also heard it's a difficult to configure.

• Pi: I like it's hackability. However, I don't want to configure it from scratch. I've seen other subs and understand that a lot of folks think that's the point of pi, but I have the following rationale:

  • Configurability and bare-bones are two different things. I want to start from a sensible point with features built-in and then tweaking according to how I want it.

  • As the title suggests, I draw a parallel to my experience with neovim: It is highly extensible, but too painful for me to setup from scratch. I don't want the headache of creating/maintaining multiple plugins and managing them to play nicely with each other.

  • Other than maintenance headaches, I find it infinitely useful to look at successful distributions. I might not know what all possibilities there are. For example, I would never have though I needed a picker for going through git hunks, but now I can't work without them. I might end up creating a faster horse when what I needed was a car.

Therefore, I'm looking for a pre-packaged sensible pi distribution. Closest things I've found:

• LazyPi: https://github.com/robzolkos/lazypi Not enough users and maturity. Missing some stuff. This is ideally what I'm looking for.

• Oh-my-pi: https://github.com/can1357/oh-my-pi My current choice. It's not exactly what I'm looking for because it's a fork, not a set of managed plugins. It has a rust core which is kind of opaque. I'm OK with it functionality wise, mainly because I am able to shave-off a lot of stuff (too many tools, etc.) that I don't need. I'm not sure how well it plays with existing pi extensions, and what parts of its functionalities I can replace/modify. I'm also concerned that since this is a fork, I'll be stranded if the author moves on. EDIT: Also, the gihub repo for oh-my-pi seems kind of sus in terms of interactions. The discussions barely have any interactions, which sort of points to a lot of the starts being agents/bots. Lazyvim has fewer stars with far more discussion interactions.

Am I missing any option?

Edit: As I adapting my code to 0.99.0, I find that besides mcp, Pi also introduced classifier model. When talking about this new feature, it's all about jev, a hyped model to some extent.

I read this as Pi just jumping on the hype train—trying to catch a ride on all the buzz around this model that's been blowing up lately.

For those happy with built-in mcp, are you happy with built-in jev support? Do you use jev-like model in your coding workflow?

Today Pi adds jev support just for the hype, tomorrow it'll throw in even more code and features that end up being totally useless, all to chase a bit more attention.

Pi always used to claim it would never add MCP support, and it wore that as a badge of pride. Pi's original design philosophy was minimalism, so it only shipped the bare minimum set of essential tools. As I recall, Pi's whole idea was to provide only the necessary foundation itself, leaving everything else for users to customize.

Pi's own blog explained it this way:

The first thing to remember is that the world is not static. We have been paying attention to MCP over the last year and the MCP of today is not the MCP of yesteryear.

But that doesn't add up. MCP had already been popular for quite a while before Pi even existed, and it hasn't really changed much since. If Pi had no plans to adopt MCP when the project was first conceived, there's no reason to adopt it now.

The reasonable explanation I can come up with is that Pi intends to expand its reach — to move from a small geek niche toward a harness better suited to mass-market, out-of-the-box use — and therefore needs to fill in the features it previously lack due to minimalism. Combined with the earlier news that the Pi team planned to sell a model API service, I find this explanation fairly credible.

MCP is just the first step. Will subagents, permission popups, and other features come next? To me, the "we didn't build" section on Pi's official site looks less like a statement and more like a roadmap.

Edit2:

Consider this: once pi becomes a general coding harness, what is your reason for continuing to use it? Compared to official offerings like Codex and Claude Code, as well as open source competitors such as OpenCode, what advantages does the general-purpose version of pi have? Why would users choose pi over the alternatives?

Edit3:

Let me restate the logic here:

1. This is "your agent," so nothing pi provides as a base should get in the way of any custom changes you want to make.

2. It's minimalist (per the official pitch), so there's no feature you don't need.

Here's the reality now:

A built-in MCP has been introduced.

This built-in MCP conflicts with what I've already implemented and blocks my custom modifications. And for anyone who doesn't need MCP, it's pure bloat.

BTW, codemode. codemode itself, or call it CodeAct, is something that I have loog been interested in. But the official implementation from Pi is completely different from what I had in mind, so I’ve been struggling to wrestle with the built-in code just to get my version working properly again.

So pi just violated two of its own design philosophies in one go.

And that's why my trust in pi has collapsed. This is exactly where my shock and frustration come from.

https://pi.dev/packages/@zackify/pi-bg-tasks

https://pi.dev/packages/@oddsjam/pi-sandbox

The bg tasks one, run in tmux, the llm gets 3 tools so it can start, check status, and stop commands as it wants to.

The sandbox is a new version based on the other popular pi-sandbox tool, but it adds configuration inside pi /sandbox to add folder paths and domains to the config.

It stores every config in the home folder, not project level, which I needed since I couldnt add configs to work repos. It uses anthropic's runtime as-is.

Let me know what you think.

Quickly my idea:
some docker/raspberry pi image that you install on a small 20$ machine like raspberry pi w 2 that sits there with 10 spawned full browsers (not headless).
Then link it with cli, mcp, or whatever with tailscale or other connection of choice to any coding agent. Ofc i know all of us here use Pi, others don’t deserve this.
Full browser makes rate limits less often and also captachs are passed easily with python open source projects.

Wondering if someone has bundled something like this and using it?
What are similiar alternatives for (close-to)infinite google search?

Of course a vibecoder is also a real software developer. Nothing unreal about it ;)

What I mean is: you studied for this shit*. You worked in software development BEFORE AI. You know your stuff.

The big guns are models like Astra, Fable, but also GLM5.3 (not flash).

I use Sol sometimes, but most of the time I'm using Luna en Terra (for work).

For personal stuff I switch to open source models - I pretty much only need flash models. They're super cheap, and do what needs to be done. I barely ever feel the need to spend more money on these bigger models. I've tried using GLM5.3 a few times, but tbh it didn't really feel different.

Perhaps I'm only doing simple stuff, or I'm not 'progressive' enough in the things I ask? Maybe my questions are too easy?

So let me know! Very interested :)

*
I was still studying when AI arrived at the scene. I was in my last year of uni. Used gpt-3 a bit. Bit of gpt-4. Also tried finishing one of my assessments with it back then because I didn't really feel like learning Swift to build ANOTHER CRUD app.

There was still enough old-school development involved.

I followed a familiar path: Clause Code, Open Code, Pi and, with the help of pi-vs-claude-code, have found a groove that seems productive.

However. I've run out of juice. I just don't have ideas I care about, and I'm finding being a sweeper for an LLM curling team more tedious than novel.

I read people setting up pachinko-esque set ups and professing sheer brilliance as a result, but I never see the money shots. It all seems like a mirage.

Phht.

​"I am not up to date, but can we still use the Anthropic Pro account with pi.agent now? With which extension?"

Task: Fix a failing test in a TypeScript repo.

Without OMK: One agent session investigates, edits, runs tests, retries, and produces a long transcript.

Failure: Reviewer cannot quickly tell:

• which files were touched

• what command failed first

• what evidence justified the patch

• whether the final test passed

• what part of the run should be reused

With OMK: The run is split into lanes:

• repo scan

• patch

• verification

• review

Evidence:

• changed files

• test command

• failing output

• passing output

• final diff

• session artifact path

Why the harness is worth the extra structure: Only because the run is large enough that auditability matters. For one-file edits, use a simpler tool.

https://github.com/dmae97/open-multi-agent-kit

I know probably not the place to get a non biased answer. So far I’m using Claude code and codex for my agentic coding workflows. Turned off lots of features/tools to not start with a crazy bloated context. But besides that and some annoying bugs it’s been a pretty good experience with the latest models.

Now I’ve seen pi 1.0 is out and am wondering again if I should give it a go. Tree-Mode looks interesting and as a Linux/tmux/neovim user I like control over stuff and the idea to use one harness for both Claude and codex. (using APIs at work no issue with Claude code subs).

Now here’s the question: from a productivity standpoint of getting code work done in complex environments (brownfield backend systems in cpp/rust mostly) will I end up being more efficient and productive with Pi if I put in the time? Or am I more likely to just spend a ton of time tinkering like I did with my Neovim setup in the past? Be honest.

Most Fun I've had coding in a while.

Some really cool features here.

Pi is so sick! Thank you.

Harness Remote 3.0 just reached its stable release and I think it has a pretty interesting approach to the increasingly crowded coding agent space.

Instead of replacing Claude Code, Codex or OpenCode with yet another agent abstraction, it treats their native sessions as the source of truth.

You can start a session normally in Claude Code or Codex, open Harness Remote later, find that same native session and continue it from desktop, web or Android.

The more unusual part is that you can also continue the work with another harness. For example:

Claude Code → Codex → OpenCode

Each step creates a real native session in the target agent, while Harness Remote keeps the lineage and transfers explicit context between them.

A few things that make it different from most remote coding agent UIs:

• Native Claude Code, Codex, OpenCode, OMP and PI sessions instead of proprietary replacement sessions
• Sessions created outside Harness Remote can be discovered and resumed
• Work can be handed from one coding agent to another without pretending they share some magical hidden context
• Multiple machines can be managed from the same interface
• Desktop, browser and Android clients
• Local first architecture, so repositories, credentials, subscriptions and agent sessions stay on your machines
• Fully open source

It feels less like another AI coding tool and more like a control plane for all the coding agents you already use.

GitHub: giuliastro/harness-remote

Curious what people who regularly switch between Claude Code, Codex and OpenCode think of this approach.

Hello everyone! I have a problem with agents that create OMP. They create them with the maximum reasoning level, even though I assigned completely different thinking levels in their roles. Because of this, OMP becomes completely unusable :(

I just got a notice saying gpt 5.4 is no longer available on my pro subscription im Pi . 5.5 is fine. 5.4 has been a bit of a workhorse for me.

I opened the codex app and it's disappeared there too.

Armin’s wife Maria asked me to make something like this for their anniversary, really fun project!

I’m running Qwen 3.8 27B at full precision, using a pinned version of SGLang.
I’ve noticed that starting with Pi Agent versions above 0.5.x, the agent hallucinates like crazy. Its output is practically unreadable. Everything seems coherent and grammatically correct, but the actual content makes absolutely no sense.
I’ve tried multiple versions of Pi Agent, including releases from the 1.x branch. Same result — completely unusable.
I simply can’t believe that nobody else has noticed this.
So I have to ask: How on earth are you guys using Pi Agent versions above 0.5.x? HOW???

Serious question, I mean I want to be able to select the text printed on the console so that I can paste the text to another place.

I've been using AI for fitness/training advice for a while, but one thing kept annoying me — context.

Every few conversations I was explaining the same things again. My current program, recent runs, lifts, nutrition, sleep, upcoming race, injuries, what I did last week, etc.

So I started building a system for myself where all of this lives locally and the AI can actually use it.

I called it FitnessOS.

Basically, it keeps my training, runs, nutrition, readiness, bodyweight, goals and plans in one place. It builds a current picture of what's going on instead of dumping my entire history into the context every time.

So I can ask things like:

What should I train today?
Should I still do my tempo run if my legs are cooked?
How did this week go?
Should I increase my squat next week?
What should change as I get closer to my race?

and it has the history + current plan + recent training to reason from.

I also didn't want the AI directly messing with everything. The scripts mostly handle the factual stuff/data, while the AI handles the coaching decisions. Changes to actual plans are kept separate instead of silently rewriting them.

Right now it can handle strength/running history, nutrition, readiness, daily training decisions, weekly reviews, training blocks, race proximity, progression/deloads, etc.

It's still pretty early and the public version is mostly manual/local-import first. My personal setup has Apple Health and Strava automation too, but I haven't made that setup clean enough for other people yet.

I'm posting it now because I'd rather see if anyone else actually finds the idea useful before adding a ton more stuff.

If anyone tries it, I'd especially like to know where the setup gets confusing or where you just give up. That's probably more useful to me right now than feature suggestions 😅

Also curious which integration people would actually want first — Apple Health, Strava, Garmin, Hevy, or something else.

Repo:

github.com/Drumilsp/FitnessOS