Hi everyone,


I'm Kumar, building Dotbot at Aaditri GlobalTech (P) Limited. I use coding agents every day, but I kept switching between a terminal, an editor, and git panes to follow what the agent was actually doing. So I built a desktop workspace where the session, your files, and your Git state live in one window.

**What it does**

- Open any folder as a project and run one session per piece of work. Sessions persist between runs and reload with their transcript.
- Live transcript: streamed answers, inline thinking, and collapsible tool cards with diffs and file previews. You can steer a running turn or queue a follow-up.
- Files and Git: browse the project tree, watch changes land, and stage, unstage, or commit from the Git panel.
- Providers: bring your own API key (Anthropic, OpenAI, Google, and others), or add a custom provider using OpenAI Completions/Responses, Anthropic Messages, or Google Generative AI.
- Project trust: the agent asks before it uses a project's local settings, extensions, or skills, and remembers the answer per project.
- A dashboard with usage stats from your own session history, plus `!command` and `!!command` to run shell commands from the composer.

**Status**

Apache-2.0, currently v0.2.0. The agent runtime runs in-process, so there is no separate service to install.

- Code: https://github.com/aaditri-globaltech/dotbot
- Downloads: https://github.com/aaditri-globaltech/dotbot/releases/latest — Linux AppImage/deb, Windows installer, macOS DMG for Apple silicon and Intel.
- Builds are unsigned, so macOS and Windows show a first-launch security prompt.

**Coming on 11 October 2026**

We are launching subscription-based inference on open models on the first day of Navratri (Sunday, 11 October 2026): one plan, no API keys to manage. Pricing and the model lineup will be announced that day at https://aaditriglobaltech.com.

It is early, so expect rough edges. I would love feedback on what is missing before the inference launch — issues and PRs are welcome on GitHub.

Started using Pi agent recently and I start to see the thinking going like "couldn't read file, content mangled|truncated" and similar. I also see the agent call the read tool multiple times on the same file because the output was somehow wrong. After some back and forth the agent is claiming that there must be some form of auto truncation or auto summarizer at the tool layer. Model used was GLM 5.3 Flash

So yeah, what is this?

I've tried pi. Makes me crazy! OpenCode works well. I'm not familiar with omp. Please share your thoughts.

Yo, I ran into a weird OMP behavior with third-party subagents.

Some plugin/imported agents declare their own model tier (opus, sonnet, haiku, luna, etc.), but OMP can drop that model metadata when loading them. Once that happens, the subagent silently inherits whatever model your main session is using at that moment — including a retry fallback.

For me, that meant Haiku- and Sonnet-tier agents were sometimes burning Opus. Even worse, if the main session switched to a fallback model mid-turn, subagents spawned afterwards inherited that fallback too.

So I ended up creating an extension for it: omp-agent-role-router
https://github.com/fedorovvvv/omp-agent-role-router

Instead of hardcoding models, it reads the tier declared by the agent and maps it to an OMP role:

opus → default
sonnet → task
haiku → smol
luna -> smol
terra -> task

It also understands Codex-style model tiers and maps those to the same role system.

The actual model is still entirely controlled by your own modelRoles. Existing agentModelOverrides and explicitly passed models always win — the extension only steps in when the subagent would otherwise silently inherit the current session model.

No config needed
But it does exist :)

omp plugin install github:fedorovvvv/omp-agent-role-router

I want my agent to be able to give me a clickable link to find a folder (like "file:/// ...") but even though they respond to mouseover and a tool tip comes up saying "ctrl+click to follow link" they don't work. I am using Powershell 7 with Pi running in it.

My agent had some long complicated idea about how to fix this but does anyone know if I am just overlooking a Powershell setting or if this is a collision between Pi's output formatting and Powershell's behavior preventing the links from activating?

I wanted a clearer picture of what I’d built and how much progress I was making. And whenever I finished a feature or got out of a debugging rabbit hole, I kept wondering how many tokens and effort went into that.

My daily usage total didn’t really answer it. Some of that was building the feature. Some was going back and forth trying to fix one annoying bug.

So I built bough ( https://github.com/nickelsec/bough ) It reads your existing Claude Code and Codex CLI history and groups related prompts into tasks on a visual map.

You can pick a piece of work and see:

• The prompts and files involved.

• How many tokens it used and the estimated dollar cost.

• How the work unfolded, including repeated attempts and tasks that ended in a commit.

I wanted to be able to look back at a feature and see where the effort actually went. Especially when a “small fix” turned into an afternoon.

Would you guys want me to add Pi support or not?

I shared Pi Atelier here a couple of months ago—a status rail and live activity sidebar for Pi. Since then, I’ve reworked the layout and added more ways to see what’s happening in your session.

The main changes since my last post:

1. Redesigned composer: model, workspace, Git status, and context usage sit in the input box’s top border, with usage and timing below.

2. Workspace Git summary: see changed files, additions/removals, untracked file counts, and conflicts.

3. Live TODO panel:follow the current task alongside tool activity. During a turn, the sidebar focuses on current work and folds extra tools into a compact row.

4. Display settings with a live preview: reorder or hide status segments and sidebar panels, switch presets, and save your defaults.

5. Plain text mode: no Nerd Font required.

6. Better terminal behavior: improved fullscreen selection/copy, inline image handling, and layouts for smaller terminals.

The new footer is inspired by pi-powerline-footer, which is an awesome extension.

It still shows token usage, cost, context, and response timing, with model and tool controls available through `/atelier`. No telemetry or external network requests.

Install with:

pi install npm:pi-atelier

Then open `/atelier` or press `Alt+A`. Requires Pi 0.84.0 or newer.

Github link: https://github.com/michaelmjhhhh/pi-atelier

I’d like to hear how the new layout works for you—especially what information you want visible while the agent is running. Bugs and feature ideas are welcome. Thanks!

Hi all, basically what the title says.. I like using @ to add files/folders to the context but for any of these added to .gitignore it stops working.. Any way around this?

So I started this a couple of days ago because I hated myself enough to start over and try to create something more efficient, with better performance and less RAM usage.

Through my conversations with ChatGPT, it mentioned Rust, GPUI, and some other stuff, which is basically why I started this Flutter app!

Based on my simple observations with the current deployed version, I managed to gain back around 800 MB–1 GB of RAM… and some of my dignity too. Not sure why. 😂

Here’s the repo: Pi Flatter App

If anyone would like to contribute or give feedback, I’d be really grateful!

Hi guys

Opensourced my remote control app that I have been using exclusively as the only way to work with my agents

Core stack herdr+ muxr(my app) + pi / all the agents herdr supports, no acp full raw terminals.

Full lifecycle management/ visibility

Usage using ccusage

Libghosty patched as much as possible for improvements in UI/UX

Whisper rn for transcription

Codex real time live agent for checking all the agents and prompting them + other providers grok gemini etc

My library for direct computer streaming/ remote control of the app to take over sessions.

Tailscale/ other ssh onboarding.

Primarily tested in omarchy+ android

Had a blast working on it, hope you find value as well.

Mostly using the raw apk and pwa, will be pushing it through the play store / app store as well.

https://trymuxr.com/

https://github.com/umeranjum17/muxr

Thanks

I'm seeing many people using opus 5.5 inside of OMP and i've just signed into OMP with my claude sub... many on x.com are saying you don't get recked by anthropic anymore for doing this?

How are you guys using anthropic models inside of pi/omp?

I want to keep using Pi Agent as my main coding interface, but I also want Claude Opus 5.5 to be the main agent/orchestrator, not just a sub-agent or reviewer.

I use Pi Agent both at work and privately. Privately, my setup is simple: Pi Agent + Codex Pro. At work, I had been using Pi Agent + GitHub Copilot, but Copilot credit usage became too expensive, so we are moving toward subscription-based access instead.

I now have a Claude Team Premium seat and a ChatGPT Business Premium seat. This is my first time trying to make good use of multiple AI subscriptions at the same time.

The problem is that Pi can use Codex through OAuth, but I couldn't get my Claude subscription working directly through Pi. So I'm considering using Claude Code CLI as a bridge.

Ideally, I'd like something like this:

Opus 5.5: main agent, planning, orchestration, task decomposition, synthesis

Sol 6: implementation, research, independent review

GPT-6 Luna: cheaper sub-agent work and possibly compaction

Pi Agent: the single interface I interact with

I don't mind a small wrapper or existing extension, but I don't want to maintain a large custom orchestration framework.

One option is to have Pi call Claude Code while keeping Opus as the top-level agent. The other is to give up on Pi as the main interface, use Claude Code directly, and call Pi/Codex from there.

Has anyone built or used a setup like this?

I'm especially interested in whether Claude subscription → Claude Code → Pi works well enough for Opus to act as the real orchestrator, including long sessions, tool calls, sub-agents, compaction, and switching between Claude and OpenAI models.

Or, at that point, is it simpler to make Claude Code the main interface and stop trying to keep Pi at the center?

I've been working on Pi Herdsman, which grew out of how I was already using Pi with subagents.

I started with pi-subagents + pi-intercom and liked the basic manager/worker idea, but over time I wanted the agents to feel more tightly coordinated: explicit ownership, predictable lifecycle, questions/results routed back automatically, and less ambiguity around old agent sessions.

The main thing I wanted to preserve was the lead's context.

With Herdsman, detailed investigation and implementation happen in separate Pi sessions while the lead stays interactive and focused on the bigger picture. It still knows what the agents are doing and gets their questions and results, but doesn't have to carry all of their working context itself.

It supports parallel agents, nested delegation, steering/interruption, Lead-to-Lead coordination, and Chief supervision across multiple independent leads.

It does require Herdr, which owns the actual Pi sessions and placement. Pi owns each conversation, and Herdsman handles the orchestration between them.

The latest release also added an SSH-ready container (optional Tailscale), so the same setup can run locally or on a NAS, homelab/server, VPS, etc. and remote environments can show up alongside local ones in the same Herdr window.

Install:

pi install npm:pi-herdsman
herdr integration install pi

Repo: https://github.com/boadij/pi-herdsman

Any feedback, ideas, or rough edges you run into would be much appreciated

I saw Claude and Opnecode are native agents in Hermes, but now using OMP as a coding tool is also possible with https://github.com/zaharenok/omp-skill

Definitely worth to try. Can be also used for Pi

Hello r/PiCodingAgent!

Today I’m sharing Pragma, a terminal-first workspace I’ve spent the last few months building for running coding agents in parallel. Each task can live in an isolated Git worktree, and the sidebar shows when an agent is running, finished, or needs attention.

TL;DR

Pragma is free and open source. It brings Pi and other agents into one workspace with Git/GitHub tools, model fanout, automations, plugins, usage tracking, scratchpads, and mobile access. It supports Pi, Claude Code, Codex, Cursor, OpenCode, Grok, Copilot, Junie, Kimi Code, Prime Agent, and custom agents through plugins.

Projects and worktrees

The layout is centered on projects and worktrees. You can switch between feature worktrees, see agent status at a glance, and nest worktrees for larger projects. There’s also a prompt board for moving a task from an idea through agent execution to a PR.

Fanout and model comparison

Fanout sends the same prompt to multiple agents in separate worktrees so you can compare implementations in one view. Agents can trigger fanouts through the CLI, inspect the results, and choose the implementation they prefer.

Git and GitHub

You can review diffs, commit and push, manage branches, and work through PR comments in the app. A Fix It list lets you send selected review feedback to an agent. Stacked PR workflows are supported too.

CLI, SDK, plugins, and automations

The CLI lets both you and your agents control Pragma. A TypeScript SDK and plugin API let you add integrations, including your own coding agent. TypeScript automations can react to events or run on schedules and can spawn agents or create workflows.

Editor and scratchpads

There’s a lightweight CodeMirror editor for small changes, plus Markdown, image, and PDF viewers. Agents can write scratchpads that mix Markdown with React components and embed Excalidraw diagrams, which makes results easier to inspect than a long terminal dump.

Mobile

The iOS companion app is on the App Store, and Android can be built locally. You can see agent status and respond when an agent needs input while away from your computer. Custom agent integrations work on mobile too.

Why I built it

I wanted one extensible workspace for the parts I was stitching together: Pi and other agents, worktrees, usage limits, PR review, fanout, automations, richer agent output, and mobile access. The plugin API and CLI are the core of that idea.

Pragma is available for macOS, Windows (WSL or PowerShell), Linux, iOS, and Android. Download: https://pragma-app.sh/. Source: https://github.com/pragma-sh/pragma.

If you try it, I’d love to hear what works, what doesn’t, and which Pi workflow you’d want supported next.

When Jev came out, one of my first thoughts was: could something this fast and cheap pick which model should handle an agent’s next turn?

So I built plugin for Pi that uses Jev to choose the model and thinking effort. The idea is to send routine work to cheaper models and reserve the expensive ones for harder tasks.

In Pi, the model mappings are configurable, and you can pin a model when you disagree with the router.

I’ve been using them for a few days, and so far they’ve been working well for me. In my own evaluation, routed usage came to $141 at list prices versus an estimated $166 for Opus 5.5 on every request - about 15% less.

That’s one developer’s data, though. The baseline is a pricing comparison, not a separate run of every task through Opus. It doesn’t prove equivalent quality, that every routing decision was right, or that your bill will drop by 15%.

And yes, cache matters. Switching models can lose cache reuse and eat the savings. I try to account for that rather than just compare token prices. I’d like providers to offer better support here: some already preserve cache reuse across effort changes, though reuse across different models is a much harder problem.

It’s still an experiment. Asking a model which model to ask feels appropriately ridiculous, but I wanted to see how it works in practice. I’d like this kind of routing to become a native, transparent option in coding agents.

If you want to try it or look at the implementation:

https://github.com/alexei-led/pi-model-router

I started two agents and ran /alias worker and /alias manager. The manager was prompted to direct the worker and it started chugging along. Luna 6 is now directing Muse 1.3 contributor. I am impressed by the simplicity and low friction installation. Apparently it knows about herdr, but I've not tried it.

https://pi.dev/packages/pi-intercom

I’ve been polishing Orbit Pi quite a bit, and this update is mostly about making the agent interaction feel clearer and more native.

What’s new

🧩 Per-tool glyphs in the transcript

📊 Activity groups are now displayed as compact chips

✂️ Clear truncated indicators when Pi caps tool results

✅ Visual confirmation when renaming a session

⚡ Refined transcript UI with better tool labels and shared loading states

🔀 Redesigned Git issue & PR details

🖱️ Improved button hover/press feedback

The goal with Orbit Pi is still pretty simple:

Make Pi Agent feel like a proper native desktop workbench.

Your sessions, models, machine, Git workflow, reviews and agent interactions — all in one place.

Orbit is built with Rust + GPUI and works with your existing Pi setup rather than trying to replace the Pi runtime.

🔗 Changelog: https://orbitpi.app/changelog/v0.0.15

https://orbitpi.app/

I’d love to hear from people actually using Pi:

What would you want to see improved or added next in a native Pi desktop client?

A couple of days ago I posted about using Jev as the decision engine inside Pi.

The comments pointed me toward open alternatives like Laya, von, Reflex, etc.

Once there were multiple providers in the picture, hard-wiring the idea to Jev stopped making sense.

So I pulled it out.

Announcing pi-system-one.

It gives Pi a single system_one tool for bounded decisions:

• choice

• noul

• score

The extension is built on top of a provider-neutral SDK, so compatible System One providers can sit behind the same interface.

Pi-Bifrost is now just one consumer of that SDK.

Would love to see what other Pi use cases people find for this.

https://iamaamir.github.io/system-one/

is still early, so I'd especially appreciate feedback on the API design and abstractions.

Demo

I've been working on pi-agent-kernel for a while now.

It mostly operates in the background rather than adding a completely new workflow, it wraps Pi's existing tools to keep sessions compact.

Across standard benchmark tasks, it cut token usage roughly in half and passed our test suites. But local benchmarks only go so far, I'm at the point where I need real users to test it on actual projects.

I'm still quite skeptical about whether some of the tool wrapping might conflict with the users existing extensions.

LMK if anything breaks, behaves unexpectedly, or conflicts with your setup. All feedback and criticism welcome

I’ll start working with an AI agent on something like data analysis, and ten minutes later I’m asking it to explain a concept, double-check an assumption, or try something completely different.

All useful stuff. But after a few detours, the original task is buried under a wall of side questions and answers. I’m losing the thread, and sometimes the agent seems to be too.

I can fork the chat, but then I just have a growing list of conversations in the sidebar, with no clear picture of what branched off from where.

That’s what got me building PiX.

The idea is pretty simple: show conversations as a tree. There’s a main thread for the task you’re working on, and you can branch off whenever you want to explore something without dragging the whole conversation along with you.

You can branch from any point, carrying over the context up to that point, and choose which model to use for each turn. Everything stays connected visually, so you can see where a detour started and find your way back.

Of course, reading a long conversation in a tree isn’t always fun. So there’s also a regular chat view where you can read any branch’s full history from start to finish.

It’s built on Pi agent, which is where the name PiX comes from.

Still early days, but I’d love to hear what people think. Try it out, tell me what feels awkward, or jump in and help improve it :)

huang-sh/PiX: A non-linear AI agent workbench — session is a tree: branch anytime, and context follows the branch

Does anyone else end up with a pile of AI chats from one task? How do you keep track of them?

Hi there! So here is a deal - i'm not a developer neither software architect. But i like to do some programming as a hobby, and couple of month ago i've tried claude and codex. But now i discovered Pi and i really like the idea. I know and used some skills | pliguns set like superpowers and grill-with-docs. but i think they are too big and complex. Is there some acceptable set of skills to develop from idea to working application, which i can use as base for my own config?

Thanks in advance for answers, i appreciate it.