# subagentura site reference Public content generated from the same HTML served to readers. Product facts and contribution status have linked sources and review dates. Statistics are dated snapshots; comparisons are source-linked documentation reviews. --- Source: https://subagentura.tech/ # Tools that show their work. Work with Pi specialists, trace CSS variables across your workspace, and record your screen locally. All three tools are open source. [Try Pi subagents](https://subagentura.tech/pi-subagentura/#install) [Watch a session](https://subagentura.tech/pi-subagentura/#workflow-video) [Browse all projects](https://subagentura.tech/projects/) ## [pi-subagentura](https://subagentura.tech/pi-subagentura/) Run subagents inside Pi or open terminal sessions you can join. Use your own prompts and configured models. `pi -e npm:pi-subagentura` [Explore the Pi extension →](https://subagentura.tech/pi-subagentura/) [Parent and specialist Pi terminals in a recorded tmux session](https://subagentura.tech/pi-subagentura/#workflow-video) ## Explore the projects Open-source tools for Pi, your editor, and your browser. ### pi-subagentura Sub-agent infrastructure. Your prompts. Bring your own prompts and models. Launch specialists, watch their Pi sessions, and continue the conversation. Choose how much the parent coordinates. [Meet the Pi specialists](https://subagentura.tech/pi-subagentura/) [Source ↗](https://github.com/lmn451/pi-subagentura) ### CSS Variables Project-wide custom property intelligence Autocomplete, navigation, diagnostics, refactors, cascade-aware hover, and color tools across an entire workspace—not only the open file. [Choose your editor](https://subagentura.tech/css-variables/) [Source ↗](https://github.com/lmn451/css-lsp-rust) ### ScreenSilo Private local screen recording Record a tab, window, or entire screen. Preview and download the WebM locally, with no account and no upload service. [Open ScreenSilo](https://subagentura.tech/screencast/) [Source ↗](https://github.com/lmn451/screencast) ## How Pi subagents run in 2026. Our documentation study reviews 8 selected Pi extensions, including our own. Explore execution models, attachable terminals, and worktree support, with a source revision behind every classification. [Read the statistics report](https://subagentura.tech/pi-subagentura/statistics-2026/) [Compare the extensions](https://subagentura.tech/pi-subagentura/compare/) ## Open-source contributions Work on independently maintained projects. Status checked 7 November 2026. ### Chrome DevTools AXI + MCP AXI shipped Streamable HTTP client support in v0.1.35 and optional navigation output without the accessibility tree in v0.1.43. The shared-session server lives in the MCP fork. Its upstream PR closed without merging. [Case study](https://subagentura.tech/contributions/chrome-devtools-axi/) [AXI repository](https://github.com/kunchenguid/chrome-devtools-axi) [MCP upstream](https://github.com/ChromeDevTools/chrome-devtools-mcp) [MCP fork](https://github.com/lmn451/chrome-devtools-mcp) **Pull requests and release evidence** [AXI transport PR](https://github.com/kunchenguid/chrome-devtools-axi/pull/139) [AXI navigation PR](https://github.com/kunchenguid/chrome-devtools-axi/pull/179) [v0.1.43 release](https://github.com/kunchenguid/chrome-devtools-axi/releases/tag/chrome-devtools-axi-v0.1.43) [MCP fork PR](https://github.com/lmn451/chrome-devtools-mcp/pull/3) [MCP upstream PR](https://github.com/ChromeDevTools/chrome-devtools-mcp/pull/2733) ### Quill An open proposal adds local transcription through Handy models you already downloaded or a configurable command. Parakeet remains the default. [Contribution notes](https://subagentura.tech/contributions/quill/) [Quill repository](https://github.com/humanitas-labs/quill) [Open PR #76](https://github.com/humanitas-labs/quill/pull/76) ## Your prompts. Your way of working. Keep your specialist prompts and choose who does what. Use`--append-system-prompt` for your own coordination instructions, or `--orchestratorv2` for our bundled delegation guidance. `pi -e npm:pi-subagentura` [Use your own prompts](https://subagentura.tech/pi-subagentura/#your-prompts) ### You choose the work and the specialist. Watch a separate Pi session, focus or attach to its terminal, and continue with that specialist when the task changes. ### Let the parent route more of the work. Orchestratorv2 guides the parent to route clear tasks to specialists and ask you when scope needs clarification. ### Save a sequence for work you repeat. Reusable scripted workflows are available for review, research, and implementation. See the workflow guide on the product page. ## What is subagentura? subagentura is the open-source tool studio of [lmn451](https://github.com/lmn451) . Its three maintained products cover Pi sub-agent infrastructure, CSS custom-property intelligence, and local browser screen recording. Each product links its code and installation path. ### Mechanism before claim See the session, cascade, or recording lifecycle before reading a promise about it. ### Shortest path to use Install from npm, your editor marketplace, or source without walking through a sales funnel. ### Control stays yours Bring your own agents, inspect every repository, and keep private files on your machine. **Sources and review dates** ## Sources and review. Reviewed by [lmn451](https://github.com/lmn451) on 21 October 2026. The directory contains three maintained products. AXI, Chrome DevTools MCP, and Quill are independently maintained projects; their contribution status is documented in the linked case studies. - [pi-subagentura repository and releases](https://github.com/lmn451/pi-subagentura) - [CSS Variables Rust language server](https://github.com/lmn451/css-lsp-rust) - [ScreenSilo source and installation](https://github.com/lmn451/screencast) --- Source: https://subagentura.tech/blog/ # Building in the open. Notes on the problems, mechanisms, and trade-offs behind the tools I build. Read the source, follow the decisions, and take what is useful. ## Latest notes. Engineering stories by [lmn451](https://github.com/lmn451) . [Subscribe via RSS](https://subagentura.tech/blog/rss.xml) . PI / AGENT INFRASTRUCTURE 27 October 2026 ### [Why I built observable Pi subagents](https://subagentura.tech/blog/building-observable-subagents/) What it takes to inspect, steer, and recover delegated work in Pi. PI / DELEGATION 27 October 2026 ### [Human-controlled delegation for Pi subagents](https://subagentura.tech/blog/human-controlled-agent-delegation/) How prompts, model choices, and optional routing fit into a subagent workflow. EDITOR / LANGUAGE TOOLS 27 October 2026 ### [Building a CSS variable language server](https://subagentura.tech/blog/building-a-css-variable-language-server/) Making custom-property definitions, references, and cascade context visible in the editor. BROWSER / LOCAL CAPTURE 27 October 2026 ### [How ScreenSilo keeps screen recordings local](https://subagentura.tech/blog/keeping-recordings-local/) A closer look at capture, browser storage, WebM export, and the limits of local recording. --- Source: https://subagentura.tech/blog/building-a-css-variable-language-server/ # Building a CSS variable language server How a CSS custom-property language server grew across TypeScript and Rust, and why editor integrations make their capabilities explicit. By [lmn451](https://github.com/lmn451) 27 October 2026 CSS custom properties are easy to define and surprisingly hard to follow across a project. A variable may be declared in one stylesheet, used from a component, overridden by a more specific selector, or injected by a framework configuration. The [TypeScript CSS Variable LSP](https://github.com/lmn451/css-lsp) began with workspace indexing and editor features for this everyday problem. A Rust implementation now serves a wider set of document contexts and editor integrations. ## Start with the question an editor user asks Completion is useful, but it does not answer which definition applies at a particular use. The language server also provides hover information, navigation, references, rename, diagnostics, and color tooling. The Rust server tracks CSS selector specificity, source order, and DOM context so a hover can identify the matching definition at the cursor. These tools help explain a token's path through the project instead of treating every declaration as interchangeable. ## Make parsing broad, but keep it bounded The Rust server indexes CSS-family files and HTML-like documents, including style blocks and inline styles. It can extract CSS-in-JS from supported JavaScript and TypeScript string or template literals, and statically read selected CSS variables from Astro and Vite configuration. “Statically” is deliberate: supported configuration syntax is analyzed, not executed. The implementation accepts bounded, recognizable forms rather than trying to evaluate arbitrary project code. That gives useful cross-file context while keeping the language server's job understandable. Framework configurations can be expressive programs; executing them as part of editor analysis would create a different safety and reproducibility problem. The current support is scoped to the documented Astro font-variable and Vite SCSS injection cases, not every way a build system might generate CSS. ## Rust and TypeScript serve related, scoped roles The Rust server is a native executable that any LSP-aware editor can launch. The VS Code extension bundles Rust binaries for supported platforms and falls back to the TypeScript server when a Rust binary is unavailable. The original TypeScript server remains a useful Node-based implementation with project-wide indexing, completion, hover, navigation, rename, diagnostics, and color features. The implementations are not feature-identical. The Rust README documents capabilities such as CSS-in-JS extraction, DOM-aware hover, and static Astro/Vite configuration analysis that are not listed as TypeScript server features. The TypeScript implementation's own limitations document says its cascade display does not model DOM hierarchy. That is why the VS Code fallback is best described as a compatibility path, not a promise that every Rust-specific analysis is available in either runtime. ## Let editor integrations choose the practical route The [Rust server repository](https://github.com/lmn451/css-lsp-rust) documents standalone use through stdio for LSP clients. The [VS Code extension](https://github.com/lmn451/css-variables-vscode) manages server selection and fallback. Zed consumes Rust release binaries through its extension; editor integrations handle their own platform and launch details. ## Follow the implementation in the projects Read the Rust server's [feature overview](https://github.com/lmn451/css-lsp-rust#features) alongside the TypeScript server's [documented features](https://github.com/lmn451/css-lsp#features) and [known limitations](https://github.com/lmn451/css-lsp/blob/master/LIMITATIONS.md) . For installation links and a live capability summary, visit the [CSS Variables project page](https://subagentura.tech/css-variables/) . [← All field notes](https://subagentura.tech/blog/) [Explore the projects →](https://subagentura.tech/projects/) --- Source: https://subagentura.tech/blog/building-observable-subagents/ # Why I built observable Pi subagents How pi-subagentura keeps delegated work visible with real child sessions, ordered artifact events, and recoverable completion delivery. By [lmn451](https://github.com/lmn451) 27 October 2026 I wanted delegation in Pi to be something I could inspect and steer, not a handoff that disappeared into a status label. When requirements change, I want to return to the same specialist and see the work in progress. For interactive children, I also want the artifact-backed result to be recoverable after a parent continuity transition. That is the engineering problem behind [pi-subagentura](https://subagentura.tech/pi-subagentura/) , an open-source extension for the [Pi coding agent](https://pi.dev/) . It supports lightweight in-process jobs, reusable workflows, and interactive children that run as separate Pi sessions in tmux, Zellij, or Herdr. The interactive path is designed for work that benefits from visibility and follow-up. ## A child session is a place you can return to An interactive child is a real Pi process with its own conversation. The parent can check its status, inspect recent activity and saved output, send a follow-up, or focus or attach to the multiplexer pane. When the task changes, continuing the existing conversation preserves the specialist's working context instead of turning every update into a fresh assignment. I wanted the session and control surface to be useful with the prompts people already have. People choose how much to coordinate directly and whether to enable Orchestratorv2 routing. The [recorded walkthrough](https://subagentura.tech/pi-subagentura/watch/) shows parent and child sessions and how their work can be inspected. ## Make events carry identity, not just timestamps Interactive children write protocol-v2 lifecycle records to an append-only NDJSON artifact log. A turn has a Pi-derived `turnId`; each record has an `eventId`. The parent advances a byte cursor over complete lines, so physical file order determines which event comes next. Timestamps remain useful for display and latency, but they cannot reorder events or decide which output belongs to a turn. That distinction matters when processes are delayed or clocks disagree. A completion record points to an immutable snapshot under `outputs/.md`, captured before the completion event is appended. The mutable `output.md` file is only staging for the active turn; it is not historical proof of a finished result. Snapshot writers enforce a byte limit before reading child-controlled output, and record explicit error metadata if a snapshot cannot be saved. The event and snapshot contract is implemented by the [artifact writer](https://github.com/lmn451/pi-subagentura/blob/1dff4a5598e243c3c46a323a6e8ac5eb535b042d/src/artifact.ts) . ## Keep the handoff and cursor in step The parent polls child artifacts and converts terminal records into coordinated completion deliveries. The poller enqueues a delivery intent before advancing its in-memory cursor, then writes both in the same state update. If it stops before that write, the old cursor causes the event to be read again; after the write, the pending intent can be delivered. Delivery identifiers are deterministic for a parent session, child, and turn. Persisted receipts let rehydration reconcile work already handled, while pending intents can be replayed after a continuity transition. This is bounded, at-least-once delivery: a crash in the dispatch window can still produce a duplicate. The guarantee is recovery-oriented, not exactly-once delivery. The [delivery queue](https://github.com/lmn451/pi-subagentura/blob/1dff4a5598e243c3c46a323a6e8ac5eb535b042d/src/delivery.ts) persists these intents, and [rehydration](https://github.com/lmn451/pi-subagentura/blob/1dff4a5598e243c3c46a323a6e8ac5eb535b042d/src/rehydrate.ts) restores the state used to replay them. Interactive artifact-backed children can be restored on parent startup, reload, or resume for the matching session. Fresh `new` and `fork` transitions have different cleanup semantics. In-process jobs and background workflows are scoped to the parent session and do not survive replacement in the same way. ## Keep the recovery contract narrow Persisting state creates a compatibility contract. The interactive state file is versioned, and unsupported shapes are preserved rather than silently rewritten. Protocol-v2 events are validated; the extension does not infer missing completion history from the session transcript or timestamps. The transcript can still supply recent activity previews. This makes some old artifacts unreadable by a newer runtime, but keeps recovery behavior explicit. The workflow runner has a different boundary. It executes trusted, agent-authored JavaScript in a VM that improves determinism; that VM is not a security sandbox. Its jobs are parent-session scoped and are retired when that session shuts down. Durable child artifacts and session-scoped workflow jobs solve different problems, so the extension does not imply that every kind of background work survives a restart. ## Visibility changes how delegation feels A status label alone does not make delegation understandable. A live child session, bounded activity preview, readable per-turn output, and a way to send the next instruction let the parent and specialist keep a shared line of work. The artifact protocol supplies the record of what happened; the terminal remains the place to inspect and continue the conversation. See the [pi-subagentura overview and recorded walkthrough](https://subagentura.tech/pi-subagentura/) . [← All field notes](https://subagentura.tech/blog/) [Explore the projects →](https://subagentura.tech/projects/) --- Source: https://subagentura.tech/blog/human-controlled-agent-delegation/ # Human-controlled delegation for Pi subagents A look at prompt-guided routing in Pi, what it can make easier, and where human control and clear limits still matter. By [lmn451](https://github.com/lmn451) 27 October 2026 Delegation is useful when a task has clear pieces that can be owned by different specialists. It is less useful when the parent silently decides what to hand off, or when a child runs somewhere the person cannot inspect. In Pi, [pi-subagentura](https://github.com/lmn451/pi-subagentura) is built around making that handoff visible and steerable. ## Routing guidance, with the person still in charge I made the extension's `--orchestratorv2` mode give the parent agent routing guidance: send clear work to attachable interactive subagents, ask when a request is ambiguous or a narrow request has no matching specialist, and leave specialist repository work to the child that owns it. Broad work can be decomposed into new children. You can also provide your own agent profiles and tell Pi when to use them. Your prompts, models, and choice about how much to delegate remain yours. This is prompt-guided behavior. It does not technically disable the parent agent's other tools or guarantee that every eligible task will be delegated. That distinction matters: routing instructions can shape the default behavior, but they are not an enforcement boundary. If a workflow needs a repeatable scripted sequence, a saved code workflow can express that sequence. Neither the router nor the workflow VM is a security boundary. ## Make the work inspectable Interactive subagents run as separate Pi sessions in supported terminal multiplexers. You can watch their activity, inspect captured output, attach to a session, send a follow-up, or cancel it. For lighter work, the extension also offers in-process delegation. These are different execution choices: a separate session gives you a place to inspect and continue the child conversation, while an in-process job avoids starting another Pi session. Visibility is useful even when it cannot identify the cause of a stall. A quiet child could be waiting on a model response, an external tool, or still doing work. The extension exposes controls and recorded state; it does not infer that inactivity means failure or automatically terminate every quiet child. ## Choose the right mode for the work Use `--orchestratorv2` when you want an interactive parent to route work to specialists or create children for broader tasks. Use the workflow-oriented `--orchestrator` mode or `/workflow` when the process itself should be a reusable script: code defines which agents run, how results move between stages, and when the workflow is complete. The router chooses where a request goes; a workflow defines a repeatable program. ``` pi --orchestratorv2 # Or add your own routing instruction: pi --orchestratorv2 --append-system-prompt \ 'Use my specialist profiles in ./agents when delegating.' ``` The example adds guidance; it does not create a hard rule. See the [router documentation](https://github.com/lmn451/pi-subagentura#orchestratorv2-thin-router-mode) and the [terminal session guide](https://subagentura.tech/pi-subagentura/guides/terminal-sessions/) for setup and operation details. The implementation's [routing prompt source](https://github.com/lmn451/pi-subagentura/blob/1dff4a5598e243c3c46a323a6e8ac5eb535b042d/ORCHESTRATOR_V2_SYSTEM_PROMPT.md) contains the routing instructions themselves. ## Try a small handoff first Install pi-subagentura, start with one bounded task, and decide whether you want a child Pi session or lightweight in-process work. Keep the task and ownership clear, then inspect the result before expanding the delegation. The [project overview](https://subagentura.tech/pi-subagentura/) has installation steps, workflow documentation, and a recorded demonstration. [← All field notes](https://subagentura.tech/blog/) [Explore the projects →](https://subagentura.tech/projects/) --- Source: https://subagentura.tech/blog/keeping-recordings-local/ # How ScreenSilo keeps screen recordings local The browser APIs and storage choices behind ScreenSilo's local recording workflow, and the limits of what local-first means. By [lmn451](https://github.com/lmn451) 27 October 2026 A screen recorder often turns a short capture into a cloud workflow: create an account, upload the video, and retrieve or share it later. ScreenSilo takes a narrower route. It is a browser extension for capturing a selected tab, window, or screen, previewing the result locally, and downloading a WebM file when you want one. I built ScreenSilo around a local recording path: the extension has no account or upload service, and it does not transmit recordings to a developer-operated backend. That is a product boundary that can be checked against its code and privacy policy, not a claim that a local browser profile is immune to other software or people with device access. ## Start with the browser's capture prompt ScreenSilo uses the browser's native capture flow, so the person recording chooses the surface in the browser's picker. The extension can capture a tab, window, or entire screen; optional microphone and system or tab audio depend on browser, operating system, and capture surface. Browser support and available audio sources are not identical across Chrome, Edge, and Firefox. Once capture starts, browser media APIs deliver the stream for local recording. A toolbar control or small in-page overlay can stop the capture, after which the extension offers a local preview. Keeping the start and stop controls near the browser surface makes the path easy to understand: choose, record, stop, preview, then decide whether to download or delete. The [ScreenSilo source repository](https://github.com/lmn451/screencast) and its [v0.2.3 release notes](https://github.com/lmn451/screencast/releases/tag/v0.2.3) document the implementation and browser-specific release details. ## Persist chunks so recording can recover ScreenSilo stores recording chunks and metadata in browser-managed IndexedDB. This lets the extension build a preview and recover local recording state when supported after a Chromium service worker is suspended or a recording is interrupted. The extension also keeps a bounded local diagnostic history for troubleshooting; diagnostics are separate from the captured audio and video. Local storage does not mean encrypted storage. ScreenSilo's recordings in IndexedDB are unencrypted, and the browser profile remains on the device. A downloaded file is a separate copy; downloading does not automatically erase the browser-stored recording. Delete each copy from the place where it lives, and protect access to the device and browser profile accordingly. The [privacy policy](https://subagentura.tech/screencast/privacy/) describes what the extension stores, how it is retained, and what the user can remove. ## Keep extension behavior separate from the website A product site may use analytics even when the extension does not. Those are separate programs with separate data practices. ScreenSilo's extension does not load the site's analytics code or send recording data to a server; the site has its own analytics, while the privacy-policy page disables analytics initialization and client-side navigation to avoid carrying it over from another page. The extension also avoids broad host access such as ``. Its permissions support the capture controls, local session state, and recovery flow. Permission details differ between browser packages, so the policy explains those differences instead of presenting one manifest as universal. ## Local-first is a boundary, not a magic word A local workflow removes a server-side upload step, but it still asks you to trust the extension code, the browser, and the device that stores the files. For ScreenSilo, the useful questions are concrete: which surface did I select, where is the recording stored, what happens when I download it, and how do I remove both copies? The answers are visible in the extension's lifecycle, storage implementation, and privacy policy. ScreenSilo's [product page](https://subagentura.tech/screencast/) links to installers and source builds, alongside browser-specific notes. [← All field notes](https://subagentura.tech/blog/) [Explore the projects →](https://subagentura.tech/projects/) --- Source: https://subagentura.tech/contributions/chrome-devtools-axi/ # Shared Chrome access for AXI and MCP. Multiple clients, one long-lived Chrome connection. Client transport support is released in [Chrome DevTools AXI](https://github.com/kunchenguid/chrome-devtools-axi) ; shared MCP sessions are implemented in a maintained [Chrome DevTools MCP fork](https://github.com/lmn451/chrome-devtools-mcp) . **AXI transport** Released: [PR #139](https://github.com/kunchenguid/chrome-devtools-axi/pull/139) merged 12 September 2026 and included in [v0.1.35](https://github.com/kunchenguid/chrome-devtools-axi/releases/tag/chrome-devtools-axi-v0.1.35) . **AXI navigation output** Released: [PR #179](https://github.com/kunchenguid/chrome-devtools-axi/pull/179) in [v0.1.43](https://github.com/kunchenguid/chrome-devtools-axi/releases/tag/chrome-devtools-axi-v0.1.43) ; opt-in metadata-only output for `newpage` and `selectpage`. **AXI release at review** [v0.1.45](https://github.com/kunchenguid/chrome-devtools-axi/releases/tag/chrome-devtools-axi-v0.1.45) , published 25 October 2026. The versions above identify where each contribution first shipped. **MCP server** Maintained fork: [Chrome DevTools MCP](https://github.com/lmn451/chrome-devtools-mcp) , with server work merged in [fork PR #3](https://github.com/lmn451/chrome-devtools-mcp/pull/3) . **Upstream MCP** [PR #2733](https://github.com/ChromeDevTools/chrome-devtools-mcp/pull/2733) closed without merge; [issue #2188](https://github.com/ChromeDevTools/chrome-devtools-mcp/issues/2188) remains open. ## One shared Chrome connection, two cooperating pieces. Multiple clients can use the same long-lived Chrome instance and page inventory. AXI selects how each client connects; the maintained MCP fork provides the HTTP server and separate MCP context and state for each HTTP client. ### Choose the connection path for each bridge. Direct Streamable HTTP and a compatible stdio proxy connect AXI to the shared service; without a server URL, its existing standalone stdio mode remains available. ## Three transport modes. AXI reads `CHROME_DEVTOOLS_AXI_MCP_SERVER_URL` and, when present with a nonblank value, `CHROME_DEVTOOLS_AXI_MCP_PATH` to select its client connection mode. ### Direct Streamable HTTP Set `CHROME_DEVTOOLS_AXI_MCP_SERVER_URL` and leave `CHROME_DEVTOOLS_AXI_MCP_PATH` unset or blank. AXI connects directly to the shared endpoint over Streamable HTTP; it does not start a local MCP child in this mode. `SERVER_URL set · PATH unset / blank` ### Stdio proxy Set both `CHROME_DEVTOOLS_AXI_MCP_SERVER_URL` and a nonblank `CHROME_DEVTOOLS_AXI_MCP_PATH`. AXI uses the local stdio child as a proxy after the compatibility check succeeds. `SERVER_URL set · PATH set` ### Standalone stdio With no shared MCP server URL, AXI keeps its existing standalone stdio transport. `SERVER_URL unset` ## Metadata-only navigation for eval chains. Navigation-to-eval and chained page-level workflows may not need an automatically printed accessibility tree. AXI’s opt-in `--no-snapshot` flag on `newpage` or `selectpage` prints page metadata without the tree or snapshot-derived suggestions, so you can continue with `eval` when no UIDs are needed. ### Navigate, then evaluate. Open a page and continue to eval without printing the automatic tree. ``` newpage --no-snapshot https://example.com eval 'document.title' ``` ### Select, then continue. Choose an existing page and continue without printing the automatic tree. `selectpage --no-snapshot 2` Default navigation output is unchanged; `--no-snapshot` is opt-in, and `--full` does not override it. An explicit `snapshot` remains available for UID-based `click` or `fill` work. Snapshot capture and reference-freshness checks still run: this AXI CLI option changes printed output only, not browser or MCP behavior. ## The MCP server implementation lives in a maintained fork. It serves loopback Streamable HTTP at `/mcp`, reuses one BrowserManager, Chrome instance, and page inventory, and creates a separate MCP server and context for each HTTP client. ### Chrome DevTools MCP: per-client sessions. Merged in [fork PR #3](https://github.com/lmn451/chrome-devtools-mcp/pull/3) , the implementation keeps selected-page, roots, trace, recording, and request-mutex state per client. It also provides a stdio-to-HTTP proxy and cleans up sessions when clients disconnect. ### Proposal closed; request remains open. Upstream [PR #2733](https://github.com/ChromeDevTools/chrome-devtools-mcp/pull/2733) proposing HTTP transport was closed without merge. The request remains tracked in open [issue #2188](https://github.com/ChromeDevTools/chrome-devtools-mcp/issues/2188) ; its [progress note](https://github.com/ChromeDevTools/chrome-devtools-mcp/issues/2188#issuecomment-6151860776) summarizes scope and limits. ## Shared Chrome, per-client MCP state. Separate MCP contexts do not isolate browser access: all clients use the same Chrome instance and page inventory. SHARED ### One Chrome, shared pages Clients can act on the same browser and page surface. PER CLIENT ### Separate MCP state Selected page, roots, trace, recording, and request-mutex state are per client. NO GLOBAL LOCK ### No cross-client mutex The server does not globally serialize operations across clients. LOOPBACK + SSH ### Not a public service Remote access uses an SSH tunnel; the endpoint is not a public authenticated service. ## Explore the AXI release and MCP fork. Chrome DevTools AXI maintains the released client transport change; the shared server implementation is maintained in the Chrome DevTools MCP fork. [Back to Projects](https://subagentura.tech/projects/) [Visit AXI project](https://github.com/kunchenguid/chrome-devtools-axi) [Visit MCP fork](https://github.com/lmn451/chrome-devtools-mcp) [Visit MCP upstream](https://github.com/ChromeDevTools/chrome-devtools-mcp) ## AXI and shared Chrome questions. Practical answers before you install or use the code. ### Is shared Chrome support released upstream? AXI's client transport support shipped in v0.1.35. The shared-session MCP server is implemented in lmn451's maintained Chrome DevTools MCP fork. Upstream MCP PR #2733 closed without merge; issue #2188 remains open as of 7 November 2026. ### Does --no-snapshot skip browser work or guarantee token savings? No. Released in AXI v0.1.43, --no-snapshot suppresses the automatic accessibility tree and snapshot-derived suggestions printed by newpage and selectpage. Snapshot capture and reference-freshness checks still run. Real-workflow token and latency savings have not been measured. ### Are clients isolated from each other's browser pages? No. Clients share one Chrome instance and page inventory. Selected page, roots, trace, recording, and request-mutex state are separate per MCP client, but there is no global cross-client lock or browser-access isolation. Remote access is documented through an SSH tunnel to the loopback service. ## Sources and review. Reviewed by [lmn451](https://github.com/lmn451) on 7 November 2026. Contribution status was checked against the linked pull requests, release records, and issue trackers. Release numbers identify the contribution's release, not a claim about the newest available version. - [kunchenguid/chrome-devtools-axi/pull/139](https://github.com/kunchenguid/chrome-devtools-axi/pull/139) - [kunchenguid/chrome-devtools-axi/releases/tag/chrome-devtools-axi-v0.1.35](https://github.com/kunchenguid/chrome-devtools-axi/releases/tag/chrome-devtools-axi-v0.1.35) - [kunchenguid/chrome-devtools-axi/pull/179](https://github.com/kunchenguid/chrome-devtools-axi/pull/179) - [kunchenguid/chrome-devtools-axi/releases/tag/chrome-devtools-axi-v0.1.43](https://github.com/kunchenguid/chrome-devtools-axi/releases/tag/chrome-devtools-axi-v0.1.43) - [kunchenguid/chrome-devtools-axi/releases/tag/chrome-devtools-axi-v0.1.45](https://github.com/kunchenguid/chrome-devtools-axi/releases/tag/chrome-devtools-axi-v0.1.45) - [lmn451/chrome-devtools-mcp/pull/3](https://github.com/lmn451/chrome-devtools-mcp/pull/3) - [ChromeDevTools/chrome-devtools-mcp/pull/2733](https://github.com/ChromeDevTools/chrome-devtools-mcp/pull/2733) - [ChromeDevTools/chrome-devtools-mcp/issues/2188](https://github.com/ChromeDevTools/chrome-devtools-mcp/issues/2188) --- Source: https://subagentura.tech/contributions/quill/ # More local transcription choices for Quill. lmn451 proposed adding adapters for [Handy](https://github.com/cjpais/Handy) and configurable local commands to [Quill](https://github.com/humanitas-labs/quill) , a macOS meeting recorder and transcriber. The change keeps Quill's built-in Parakeet path as the default. **Pull request** [PR #76](https://github.com/humanitas-labs/quill/pull/76) is open and unmerged. **Release** The adapter change is pending upstream review. The [GitHub releases page](https://github.com/humanitas-labs/quill/releases) lists no releases at the review date. **Author** [lmn451](https://github.com/lmn451) proposed the change in humanitas-labs/quill. **Related request** [Issue #75](https://github.com/humanitas-labs/quill/issues/75) is also open. ## Honor the configured engine. The proposal addresses a mismatch: Quill's transcription path used Parakeet regardless of a configured engine, leaving Handy's already-downloaded models and other local command-line engines unavailable through configuration. The change adds provider selection without replacing the existing default. ### Choose an engine; keep transcription local. A shared provider selection is proposed for transcription and `quill doctor`. Handy can reuse a model the user has already downloaded in Handy, while a custom command can wrap another local inference engine. The proposal does not add cloud providers or automatic model downloads. ## Three proposed provider paths. The engine is selected in Quill's configuration. These are behaviors described by open PR #76, not features available in a released version. ### Parakeet stays built in The existing on-device Parakeet engine remains the default. Users who do not choose another engine keep that path; the proposal does not replace it. `engine: "parakeet"` ### Reuse an installed Handy model With `transcription.engine` set to `handy`, the adapter would call Handy's headless CLI and pass an explicit configured model ID. That ID is independent of the model selected in Handy's UI. The model must already be downloaded in Handy; this path does not download it. `engine: "handy"` ### Connect a local executable or wrapper The proposed `command` provider runs a configured executable with literal argument templates, including the audio and model values. A wrapper can adapt another CLI, but it must perform local inference and return the documented JSON output; Quill is not proposing a cloud service. `engine: "command"` ## Select a Handy model explicitly. In the proposal, optional provider fields live inside `transcription` in `~/.config/quill/config.json`. This example follows the pinned Quill documentation; use the ID for a model you have already downloaded in Handy. ### Handy engine with a configured model ID ``` { "transcription": { "engine": "handy", "handy_model": "handy-computer/parakeet-unified-en-0.6b-gguf/parakeet-unified-en-0.6b-Q8_0.gguf" } } ``` The example ID is documented in the proposal's README. The Handy UI's current selection does not override Quill's configured ID, and Quill does not fetch a missing model. ## Check capability and readiness separately. The proposed diagnostics check whether the selected provider can be used; they do not claim that every custom wrapper has been validated end to end. HANDY CLI ### Required headless commands The Handy build needs `--transcribe-file`, `--list-models`, and `--json`. MODEL ### Already downloaded The configured Handy model must appear as available locally; the proposed doctor check verifies this before transcription. CUSTOM COMMAND ### Executable check is limited For a custom provider, `quill doctor` checks the executable. A test recording is still needed to check the model and JSON output compatibility. ## Text output means coarser timestamps. The Handy file interface returns text without word-level timestamps. The proposed adapter converts audio to 16 kHz mono, 16-bit PCM WAV, then processes chunks of at most five minutes. For each nonempty chunk, it would create one segment using the chunk's actual audio duration and offset it onto the recording timeline. ### Chunk boundaries are visible in precision. One coarse segment per chunk is less precise for overlapping conversation than Parakeet's word-based segments. Each Handy chunk starts a new process and reloads the model, so context can be lost at chunk boundaries. The timing proposal also carries chunk and recording-segment offsets, rather than claiming word-level alignment for Handy text. ## Inspect the proposal and its source projects. Quill remains the project maintained by humanitas-labs; Handy remains the separate project maintained by cjpais. PR #76 is open and has not been merged or released. [Back to Projects](https://subagentura.tech/projects/) [Visit Quill repository](https://github.com/humanitas-labs/quill) [Open PR #76](https://github.com/humanitas-labs/quill/pull/76) [Pinned Quill docs](https://github.com/humanitas-labs/quill/blob/52c1f5c775bb6e0baaee7a7a20c14afba54683cb/macos/README.md) [Issue #75](https://github.com/humanitas-labs/quill/issues/75) describes the provider request. The pinned [macOS README](https://github.com/humanitas-labs/quill/blob/52c1f5c775bb6e0baaee7a7a20c14afba54683cb/macos/README.md) documents the proposed config and limits. See also the [Quill upstream repository](https://github.com/humanitas-labs/quill) and [Handy upstream repository](https://github.com/cjpais/Handy) . ## Quill proposal questions. Practical answers before you install or use the code. ### Can I use these adapters in a released Quill version? This page documents proposed code, not a released Quill feature. As of 7 November 2026, humanitas-labs/quill PR #76 is open and unmerged. Review the linked PR and its pinned documentation before testing the proposal. ### Does the proposal replace Parakeet or download Handy models? No. Parakeet remains the default. The proposed Handy adapter uses an explicit configured model ID that must already be downloaded in Handy. It requires a Handy build with the documented headless CLI capabilities; the model selected in Handy's UI does not override Quill's configured ID. ### Does Handy transcription provide word-level timestamps? No. The documented Handy file interface returns text. The proposed adapter processes audio in chunks of at most five minutes and creates one coarse segment per nonempty chunk. Each chunk reloads the model and can lose context at its boundary. Custom-command compatibility still needs a test recording. ## Sources and review. Reviewed by [lmn451](https://github.com/lmn451) on 7 November 2026. Contribution status was checked against the linked pull requests, release records, and issue trackers. Release numbers identify the contribution's release, not a claim about the newest available version. - [humanitas-labs/quill/pull/76](https://github.com/humanitas-labs/quill/pull/76) - [humanitas-labs/quill/issues/75](https://github.com/humanitas-labs/quill/issues/75) - [humanitas-labs/quill/releases](https://github.com/humanitas-labs/quill/releases) - [humanitas-labs/quill/blob/52c1f5c775bb6e0baaee7a7a20c14afba54683cb/macos/README.md](https://github.com/humanitas-labs/quill/blob/52c1f5c775bb6e0baaee7a7a20c14afba54683cb/macos/README.md) - [cjpais/Handy](https://github.com/cjpais/Handy) --- Source: https://subagentura.tech/css-variables/ # CSS Variables LSP. Know which value wins. Project-wide autocomplete, hover, navigation, rename, diagnostics, and color tools for CSS custom properties—not only the file currently open. [Install for VS Code](https://marketplace.visualstudio.com/items?itemName=miclmn451.css-variables-vscode) [Install for Zed](https://zed.dev/extensions/css-variables) [32,599 Zed gallery downloads](https://subagentura.tech/css-variables/#distribution) Observed 21 Oct 2026 Six packaged targets ## Follow a variable through the whole project. CSS custom properties are dynamic and contextual. The server keeps the speed of editor tooling while accounting for the cascade that decides what users see. ### One workspace view Index definitions and usages in stylesheets, HTML, component files, and supported static Astro and Vite config. Parse supported CSS-in-JS in open JS/TS files. ### The value that applies Hover accounts for !important, specificity, source order, and DOM context so competing definitions appear in useful order. ### Move and refactor Jump to definitions, find references, and rename variables across the indexed workspace without losing fallbacks. ### Fix the rough edges Diagnose undefined variables, create missing :root definitions, add fallbacks, and replace literal colors with existing tokens. ## Workspace-wide completion, for real. A real Zed session running the Rust LSP. Suggestions include variables indexed from Astro, HTML, Svelte, SCSS, and JavaScript sources. Supported config is statically analyzed; arbitrary JavaScript is never executed. Zed showing CSS variable autocomplete with values and definition paths from Astro, HTML, Svelte, SCSS, and JavaScript files CSS Variables · project-wide suggestions in Zed [Evidence: resolved issue #16 ↗](https://github.com/lmn451/css-variables-zed/issues/16#issuecomment-4885155079) ## Choose the shortest install path. Dedicated clients for VS Code and Zed; standalone Rust and TypeScript servers everywhere else. VS CODE ### Install the extension Native Rust servers for major platforms with a TypeScript fallback. [Marketplace ↗](https://marketplace.visualstudio.com/items?itemName=miclmn451.css-variables-vscode) [Source ↗](https://github.com/lmn451/css-variables-vscode) ZED ### Install from Zed Native server discovery, download, caching, and fallback resolution. [Zed gallery ↗](https://zed.dev/extensions/css-variables) [Source ↗](https://github.com/lmn451/css-variables-zed) ANY LSP EDITOR ### Run the Rust server Use Neovim, Helix, Emacs, or any client that launches an LSP over stdio. [crates.io ↗](https://crates.io/crates/css-variable-lsp) [Source ↗](https://github.com/lmn451/css-lsp-rust) UNIVERSAL FALLBACK ### Use the npm server The TypeScript implementation remains available for Node-compatible environments. [npm package ↗](https://www.npmjs.com/package/css-variable-lsp) [Source ↗](https://github.com/lmn451/css-lsp) ## Native first. Portable by design. Four public components have separate versions and distribution paths. The feature descriptions above refer to the Rust server; the TypeScript fallback differs in cascade modeling and code actions. CLIENT / A ### VS Code Bundled native binaries with an automatic TypeScript fallback. CLIENT / B ### Zed Native discovery, download, caching, and fallback resolution. CORE / C ### Rust LSP Standalone stdio server and embeddable library. Release v0.3.7 provides Linux, macOS, and Windows binaries for x86_64 and aarch64. FALLBACK / D ### TypeScript LSP npm v1.0.22 supports Node 20 or Node 22 and later. Cascade modeling is best-effort and does not model DOM nesting or selector combinators. ## CSS Variables distribution snapshot. Observed 21 October 2026. These public counters have different definitions and periods. They are not unique users, active usage, installs, or performance benchmarks, and must not be summed. [Download the sourced JSON snapshot](https://subagentura.tech/css-variables/stats.json) | Counter | Value | Scope and source | | --- | --- | --- | | Zed gallery downloads | 32,599 | Gallery counter at observation time; [official Zed listing](https://zed.dev/extensions/css-variables) . No time window is asserted. | | npm TypeScript server · 30 days | 131 | [2026-09-19 through 2026-10-18, inclusive](https://api.npmjs.org/downloads/point/2026-09-19:2026-10-18/css-variable-lsp) . Package downloads can include repeat and automated downloads. | | npm TypeScript server · 7 days | 5 | [2026-10-12 through 2026-10-18, inclusive](https://api.npmjs.org/downloads/point/2026-10-12:2026-10-18/css-variable-lsp) . Package downloads can include repeat and automated downloads. | | Component | Version | Release or listing | | --- | --- | --- | | Rust language server | 0.3.7 | [Primary source](https://github.com/lmn451/css-lsp-rust/releases/tag/v0.3.7) | | VS Code extension | 0.3.6 | [Primary source](https://marketplace.visualstudio.com/items?itemName=miclmn451.css-variables-vscode) | | Zed extension | 0.1.1 | [Primary source](https://zed.dev/extensions/css-variables) | | TypeScript language server | 1.0.22 | [Primary source](https://registry.npmjs.org/css-variable-lsp/latest) | The Zed gallery labels its v0.1.1 listing updated 14 August 2026. The Rust v0.3.7 release was published 11 September 2026. The VS Code v0.3.6 documentation labels Windows ARM64 experimental. Later repository changes, including opt-in eager JS/TS scanning, are separate from those published releases. ## CSS Variables LSP questions. Practical answers before you install or use the code. ### Which editors can use CSS Variables LSP? VS Code and Zed have dedicated extensions. The standalone Rust server speaks LSP over stdio; its documentation includes Neovim and Helix setup examples. Other editors need a configured stdio LSP client. ### Does CSS Variables LSP scan CSS-in-JS? The Rust server extracts CSS from supported string and tagged-template literals in open JS/TS documents. Opt-in eager scanning of unopened JS/TS files is documented in a later repository revision, after the published v0.3.7 release. Astro and Vite configuration support analyzes documented static structures; it does not execute arbitrary configuration code. ### Does hover show which CSS variable value applies? The Rust implementation uses specificity, !important, source order, and DOM-aware matching. The TypeScript fallback documents best-effort cascade ordering without modeling DOM nesting or selector combinators. Feature descriptions on this page refer to the Rust implementation unless stated otherwise. ### Do I need Node.js to run the language server? The standalone Rust release runs without Node.js; building the Rust server from source requires Rust 1.95 or later. The npm TypeScript server supports Node 20 or Node 22 and later. Editor extensions manage their own server-discovery and fallback paths. ### What license applies to the components? The Rust server, TypeScript server, and Zed extension identify as GPL-3.0. As reviewed on 21 October 2026, the VS Code repository's LICENSE file says MIT while its README and Marketplace-rendered README say GPL-3.0. Those statements need reconciliation; this site does not assign one license to the whole product family. ## Sources and review. Reviewed by [lmn451](https://github.com/lmn451) on 21 October 2026. The gallery and package counters are dated distribution snapshots. Editor support and feature details come from the linked component sources; they are not a browser-runtime correctness or speed benchmark. - [Published Rust v0.3.7 documentation and editor setup](https://github.com/lmn451/css-lsp-rust/blob/2b1aa60d5d73ee30454e3906dc41ca70ab88ed04/README.md) - [Later Rust source: opt-in eager JS scanning](https://github.com/lmn451/css-lsp-rust/blob/122eef369ca158b1d014fa8a161e85ec87da53f0/README.md) - [VS Code v0.3.6 documentation and license files](https://github.com/lmn451/css-variables-vscode/tree/c672068f0c606e3385d32307ad709cb6c24fc4a6) - [Zed v0.1.1 release source](https://github.com/lmn451/css-variables-zed/tree/f4dde4a2a075f916ec6bd08d0d48001eba0352f5) - [TypeScript server documentation and limits](https://github.com/lmn451/css-lsp/blob/a84d4424961b0d95a723920fcbc01bcc41005843/README.md) ## Behind the build - [Building a CSS variable language server](https://subagentura.tech/blog/building-a-css-variable-language-server/) --- Source: https://subagentura.tech/pi-subagentura/ # Give Pi a team. Launch Pi specialists you can watch, steer, and join, using your own prompts and models. Interactive sessions run in tmux, Zellij, or Herdr. `pi -e npm:pi-subagentura` [Watch a real session ↓](https://subagentura.tech/pi-subagentura/#workflow-video) [Install & setup](https://subagentura.tech/pi-subagentura/#install) ## See it in a real Pi session. Watch a parent and its specialists work through a real task. This 8-minute edit preserves the session’s order, with quiet stretches accelerated and English translations. [Watch the full workflow video](https://subagentura.tech/media/pi-subagentura/workflow.mp4) 97:56 source session · 8:06 continuous edit · waits preserved at speed [Download the English transcript](https://subagentura.tech/media/pi-subagentura/workflow.english-transcript.md) **Open the translated transcript** - Yes. I reviewed the current head of PR #166. - I started two interactive subagents on Luna/max: an implementation worker in the separate worktree/branch feat/jev-routing-provider-neutral, and an architecture reviewer in feat/decision-plan-review. They communicate through pi-intercom; after the first commit I will continue with the upper layer and link the branches through gh stack. - Understood. I will wait for the subagent notification, then verify the commit and create the stacked PRs. - The second agent has written the tests; it only found missing node_modules in the new worktree. I’m waiting for the final commit before verifying both layers. - The generic decision core is implemented and in final checks; I’m waiting for its SHA before verification and stacked PRs. - The runtime agent exited after implementation but before commit. Its worktree, commit 72ca933, src/decision/* files, tests, and package allowlist survived; a new Luna/max agent continues verification and the provider-neutral branch is clean. - Which agent exactly? The decision-runtime-core agent exited after implementation but before commit. Why was the tmux pane closed? - The process exited 0 before completion while npm test was running; no stack trace or signal is recorded, and the worktree survived. - The agent confirmed bounded diagnostics with backward compatibility and no decision-routing changes. The second agent continues hardening the generic core; both work independently. - The bounded exit metadata design is good; I requested tests for signals, malformed data, parallel starts, and legacy support. - The decision stack was created. Both PRs passed the full suite and required checks; diagnostics remains a separate fix PR. - The second agent completed and committed 59f7091. PRs #168 and #169 are clean with green CI. - I started a Luna/max agent to add the OpenRouter Decisions API adapter, shared codec, tests, and top PR in stack #170. - The OpenRouter agent confirmed the shared codec approach and explicit configuration. Work continues in the top stacked branch. - I’m waiting for the commit SHA, then I’ll verify it and add the branch as the top PR in stack #170. - The mutation pilot passed on the OpenRouter branch; the only survivor is an unrelated existing baseline. PR #172 is clean with green CI and mutation results. ## From task to findings ### Give each specialist a clear task. Choose the model, prompt, and context for each session. For a code review, give one specialist the API contract and another the database tests. Review the public API contract. Report findings with file references. Showing the Delegate step. ## Keep the way you work. Prompts ### Bring your specialists. Reuse your specialist prompts and choose their context. Models ### Choose who does what. Choose a configured Pi model for each task. Control ### Join the conversation. Enter a specialist’s terminal or send a follow-up from the parent. ## Choose how the work runs. Run inside Pi or open a session you can enter. ### Delegate in-process. Use `subagent_with_context` to include the parent conversation or `subagent_isolated` for a fresh context. Run a focused task, inspect its status, and collect the result. No multiplexer is needed. [Understand context and lifetime](https://subagentura.tech/pi-subagentura/guides/faq/#in-process) ### Open an interactive child. Use `subagent_interactive` for a real session in tmux, Zellij, or Herdr. Watch the tools run, focus or attach to its terminal, and send a follow-up in the same child context. [Set up terminal sessions](https://subagentura.tech/pi-subagentura/guides/terminal-sessions/) Neither execution path creates a Git worktree automatically. Choose the child's working directory when file changes need a separate checkout. ## Your prompts. Your level of delegation. Keep the prompts and personas you have already built. Use the same infrastructure with your own instructions or our optional coordination prompt. With either approach, you can enter an interactive child's session. ### Stay in charge of who does what. Ask Pi for the specialists you need and choose their tasks, prompts, and models. Watch their progress and talk to them directly. Start with no orchestration flag, then add your own instructions below. `pi -e npm:pi-subagentura` ### Let the parent coordinate more. Try `--orchestratorv2` for bundled guidance that routes clear work to attachable specialists and reuses them for follow-ups. The parent asks for clarification when scope is ambiguous. For a clear scoped request, it can create one specialist after checking that no suitable owner exists. This is optional coordination guidance. You can still join a specialist yourself. [Read the routing guide](https://github.com/lmn451/pi-subagentura/blob/master/ORCHESTRATOR_V2_SYSTEM_PROMPT.md) `pi -e npm:pi-subagentura --orchestratorv2` **Use your own prompt files and coordination instructions** ### Bring your own sub-agent prompts. For less autopilot, tell Pi how you want to delegate. Point it at your own folder of specialist prompts: ``` pi -e npm:pi-subagentura --append-system-prompt \ "Ask me before delegating. Read the specialist prompts in ./agents and pass the chosen prompt as the child's persona." ``` Replace `./agents` with your prompt folder. The parent reads the selected file and passes its instructions to the child; the folder is not automatically imported. Already have coordination instructions in a file? Pi accepts a file path too: ``` pi -e npm:pi-subagentura --append-system-prompt ./team-instructions.md ``` After installing the extension, you can omit `-e npm:pi-subagentura`. These instructions guide the model; they do not enforce an approval gate. ## Read the handoffs and follow-ups. These two real session replays show delegation, further direction, and collected reports. A specialist can also bring in its own bounded descendants. ### Parent session Follow the parent as it delegates work and sends a follow-up to an existing specialist. [Open parent replay](https://htmlpreview.github.io/?https://gist.githubusercontent.com/lmn451/7da0271b7e863c1a215e2b7aec822c18/raw/index.html) **Preview the parent replay** ### Child session and its reviewers See a child launch recovery-safety and package/API reviewers, redirect them, and collect their findings. [Open child replay](https://htmlpreview.github.io/?https://gist.githubusercontent.com/lmn451/e4570ecfd640872efeeed72630d08f37/raw/index.html) **Preview the child replay** Replays generated with [vibe-replay](https://github.com/tuo-lei/vibe-replay) . ## Choose the control surface that fits. Several Pi extensions offer steering, continuation, and reusable agent definitions. Compare where the work runs, how you intervene, and how files are isolated. ### Pi subagents comparison 8 extensions. Documentation reviewed 21 October 2026. Source revisions, execution models, terminal interaction, worktree behavior, and tradeoffs are listed together. Maintained by pi-subagentura's creator. The guide describes documented features; it does not rank speed, cost, reliability, or popularity. [Compare eight Pi extensions](https://subagentura.tech/pi-subagentura/compare/) [Pi subagent statistics 2026](https://subagentura.tech/pi-subagentura/statistics-2026/) distills the reviewed sample into source-linked findings, with downloadable JSON and CSV. **Closest terminal alternative:** [HazAT/pi-interactive-subagents](https://subagentura.tech/pi-subagentura/compare/#hazat) also supports attachable sessions, with cmux and WezTerm options. [nicobailon](https://subagentura.tech/pi-subagentura/compare/#nicobailon) and [tintinweb](https://subagentura.tech/pi-subagentura/compare/#tintinweb) provide broader controls inside Pi. Read each project's current requirements before installing. **Public project statistics and sources** ## [Pi-subagentura download statistics 2026](https://subagentura.tech/pi-subagentura/stats/#download-statistics-2026) SNAPSHOT · 2026-10-21 **npm downloads · 30 days** 1,576 2026-09-19 — 2026-10-18[npm API source](https://api.npmjs.org/downloads/point/2026-09-19:2026-10-18/pi-subagentura) **npm downloads · 7 days** 571 2026-10-12 — 2026-10-18[npm API source](https://api.npmjs.org/downloads/point/2026-10-12:2026-10-18/pi-subagentura) **GitHub stars** 14 Repository snapshot[GitHub API source](https://api.github.com/repos/lmn451/pi-subagentura) **GitHub forks** 6 Repository snapshot[GitHub API source](https://api.github.com/repos/lmn451/pi-subagentura) npm counts include CI and repeat downloads; they do not measure unique people. [Read the dated series and method](https://subagentura.tech/pi-subagentura/stats/) · [See a scoped census of eight Pi sub-agent extensions](https://subagentura.tech/pi-subagentura/statistics-2026/) ## Know what you are delegating. Practical answers about prompts, context, recovery, and costs. These describe v4.2.1; the [released README](https://github.com/lmn451/pi-subagentura/blob/v4.2.1/README.md) is the source of truth. **What is pi-subagentura?** pi-subagentura is an open-source extension for the Pi coding agent. It provides in-process delegation, attachable child Pi sessions, progress and result tools, and reusable workflows. You supply your specialist prompts and choose models configured in Pi. **Can subagents run in-process without tmux?** Yes. The subagent_with_context and subagent_isolated tools run inside the parent Pi runtime, with inherited or fresh conversation context. They do not open attachable terminals. Interactive child sessions run as separate Pi processes and require tmux, Zellij, or Herdr. **Can I keep my own agent prompts and models?** Yes. Ask the parent to read a selected specialist prompt and pass it as the child's persona. Use --append-system-prompt for your coordination instructions, supplied as text or a file. A prompt folder is not imported automatically. The extension uses your configured Pi models and provider authentication. **Do I have to use Orchestratorv2?** No. Direct delegation works without an orchestration flag. --orchestratorv2 adds optional system-prompt guidance for routing work to attachable specialists. --orchestrator is the workflow-oriented mode. These prompts guide the model; they do not enforce a tool permission or approval boundary. **What survives a Pi restart or reload?** Standalone interactive children and their artifact-backed state can be recovered when continuing the matching parent session after reload, resume, or quit. A fresh new or fork transition cleans up owned interactive work. In-process jobs and background workflows are parent-session scoped and are retired during session replacement. **Does a separate child session isolate Git changes?** No. A separate Pi process does not automatically create a Git worktree. Choose a separate checkout or worktree and pass its working directory when agents need independent files. In-process execution and the workflow VM are not security sandboxes. **Is pi-subagentura free, and what does it send?** The extension is MIT licensed and free to install. Model usage is billed by your configured provider. Anonymous product telemetry is enabled by default; launch with --no-subagentura-telemetry to opt out. The repository's telemetry documentation defines the collected fields and other opt-out settings. [Read the full Pi subagent FAQ](https://subagentura.tech/pi-subagentura/guides/faq/) ## From first install to parallel work. Follow a concrete task, make the context and workspace choices explicit, and keep a path back into the specialist's conversation. - ### [Install Pi subagents](https://subagentura.tech/pi-subagentura/guides/install/) Check prerequisites, try pi-subagentura for one session, and choose a global or project installation. - ### [Use Pi subagents in tmux or Zellij](https://subagentura.tech/pi-subagentura/guides/terminal-sessions/) Launch visible specialists, inspect their terminals, attach, and continue the same conversation. - ### [Run a parallel code review](https://subagentura.tech/pi-subagentura/guides/parallel-code-review/) Give two specialists separate review scopes, collect evidence, and follow up on their findings. - ### [Prompts, context, and recovery FAQ](https://subagentura.tech/pi-subagentura/guides/faq/) Understand in-process delegation, terminal sessions, parent recovery, worktrees, costs, and telemetry. [All setup and workflow guides](https://subagentura.tech/pi-subagentura/guides/) ## Try pi-subagentura Use Pi SDK packages ≥1.2.0 and Node ≥22.23.2. Have tmux or Zellij installed, or run Pi inside a Herdr pane for Herdr support. Model usage follows your configured provider. ### 1. Start a Pi session Load the extension without adding it to your Pi settings. `pi -e npm:pi-subagentura` Version [v4.2.1](https://www.npmjs.com/package/pi-subagentura) . Verified 7 Nov 2026. [Read the source](https://github.com/lmn451/pi-subagentura) ### 2. Give Pi a task Start two interactive specialists in visible panes, using `background: false`. Have one review the API contract and the other check database behavior and tests. Keep both reviews read-only, return findings with file references, and keep the sessions available for follow-ups. Open `/subagents`, choose a specialist, and press `f` to enter its pane. Ask it a follow-up about a finding. ### Keep it in Pi. Install for your future sessions. `pi install npm:pi-subagentura`[npm package](https://www.npmjs.com/package/pi-subagentura) ### Keep it in this project. Install only for the current workspace. `pi install -l npm:pi-subagentura` **Context, continuity, and advanced tools** Interactive specialists can start independently, inherit the parent conversation, or receive an explicit handoff. Reusing persona instructions does not automatically import another tool's agent configuration. Standalone interactive children and their saved outputs can survive parent reloads and a restart into the same parent session. A fresh `/new` or `/fork` cleans up owned panes. In-process jobs and background workflows end with their parent session, including reload, resume, or quit. Separate child processes do not create separate git worktrees automatically. Choose working directories and worktrees to suit your task. Direct tools also support in-process delegation. For saved, trusted JavaScript workflows, see the [workflow guide](https://github.com/lmn451/pi-subagentura/blob/master/docs/workflows.md) and its `--orchestrator` mode. Workflow execution is not a security sandbox. Anonymous product telemetry is enabled by default. Start with `--no-subagentura-telemetry` to opt out, or read the [telemetry details](https://github.com/lmn451/pi-subagentura#anonymous-product-telemetry) . ## Behind the build - [Why I built observable Pi subagents](https://subagentura.tech/blog/building-observable-subagents/) - [Human-controlled delegation for Pi subagents](https://subagentura.tech/blog/human-controlled-agent-delegation/) --- Source: https://subagentura.tech/pi-subagentura/compare/ # Compare Pi subagent extensions. Terminal panes, agent controls inside Pi, or headless specialists: choose the way you want to delegate, inspect, and continue the work. By [lmn451](https://github.com/lmn451) · Updated 21 October 2026 [Setup and workflow guides](https://subagentura.tech/pi-subagentura/guides/) ## Start with how you want to work. This guide is maintained by the creator of [pi-subagentura](https://subagentura.tech/pi-subagentura/) , which is one of the options below. It compares selected projects using their own public documentation, checked on 2026-10-21. This is a documentation comparison, not a hands-on benchmark or a complete directory; it makes no claims about popularity, quality, speed, or reliability. Features can differ between the reviewed source and a package you install. - **Work in a specialist’s terminal.** pi-subagentura and HazAT’s pi-interactive-subagents launch interactive Pi sessions in supported terminal environments. - **Manage specialists inside Pi.** The other projects offer different combinations of in-process sessions, child processes, live status, transcript viewers, steering, and continuation. Check the execution and workspace rows below. - **Separate execution from workspace.** A child process does not automatically get its own Git worktree. The comparison distinguishes tools that create worktrees from those that accept or require a working directory. Several projects share the name “pi-subagents.” Publisher names and package commands below distinguish them. The [pi-subagentura project statistics](https://subagentura.tech/pi-subagentura/stats/) are separate from this feature comparison. ## Compare execution, interaction, and workspace. Each row summarizes what the project documents. Follow an extension name for context, continuation, install command, and pinned source. On a narrow screen, scroll the table horizontally. | Extension | Execution | Where you work | Workspace | | --- | --- | --- | --- | | [lmn451/pi-subagentura · this project](https://subagentura.tech/pi-subagentura/compare/#pi-subagentura) | Interactive subagents run as separate Pi processes; other tool groups offer in-process calls. | Attachable child panes in tmux, Zellij, or Herdr; inspect, focus, and message the child directly or through the parent. | Choose a working directory or worktree yourself; interactive launches do not create Git worktrees. | | [HazAT/pi-interactive-subagents](https://subagentura.tech/pi-subagentura/compare/#hazat) | Each specialist runs as a separate Pi session in a multiplexer pane. | Work in a cmux, tmux, Zellij, or WezTerm child pane; the widget tracks status and the session can be resumed. | Set a child working directory as needed; automatic Git worktree creation is not documented. | | [nicobailon/pi-subagents](https://subagentura.tech/pi-subagentura/compare/#nicobailon) | Foreground children run in the parent Pi process; background children run in a detached runner. | Use parent TUI progress and FleetView to inspect, steer, or stop runs; no multiplexer pane is required. | Workflow agents can use optional worktree isolation; foreground and background runs use their documented execution modes. | | [tintinweb/pi-subagents](https://subagentura.tech/pi-subagentura/compare/#tintinweb) | Agents run as Pi sessions in the host process; there is no multiplexer requirement. | Use Pi's widget, FleetView, transcript viewer, or @handle mentions to inspect and continue work. | Optional worktree isolation uses a repository copy and commits changes to a branch on completion. | | [mjakl/pi-subagent](https://subagentura.tech/pi-subagentura/compare/#mjakl) | Delegations normally use separate Pi processes; experimental parent-local inline workers are also available. | Headless children stream progress and results in the parent Pi interface; inline workers run locally in the parent session. | Separate processes use the selected project context; automatic Git worktree creation is not documented. | | [gotgenes/pi-subagents](https://subagentura.tech/pi-subagentura/compare/#gotgenes) | Child sessions run in the host Pi runtime; the core package does not spawn subprocesses. | Foreground results stream inline; use the widget for background runs, steering tools, or the transcript viewer. | Install the companion worktrees package for optional temporary Git worktrees with branch-saved changes. | | [Integralist/pi-subagents](https://subagentura.tech/pi-subagentura/compare/#integralist) | Subagents are nested Pi AgentSession instances inside the host process. | Navigate the live agent list, inspect and steer a full-screen child conversation, or message and resume a named agent with @handle. | Workspace isolation is not described in the project README; children are nested sessions in the host process. | | [AlexParamonov/pi-subagents-lite](https://subagentura.tech/pi-subagentura/compare/#pi-subagents-lite) | Child AgentSession instances run in the host Pi process; no multiplexer pane is required. | Use the live widget and conversation viewer to inspect, steer, stop, or continue agents from Pi. | Supply `worktree_path` to target an existing checkout or linked worktree; the tool does not create one. | ## Extension details and sources. ### lmn451/pi-subagentura · this project **Good fit** Published v4.0.1: interactive terminal sessions, direct specialist follow-ups, or optional parent-guided routing. **Requirements and tradeoffs** Interactive sessions require tmux, Zellij, or Herdr. Orchestratorv2 guides routing through a system prompt; it does not enforce a deterministic route. **Interaction** Inspect child terminals, focus a pane, attach from another terminal, and follow up with the child directly or through its parent. **Context and continuation** A child can start fresh, inherit parent context, or receive an explicit handoff. Interactive state recovers with its matching parent session; /new and /fork clean up owned panes. **Process and workspace** Interactive children are separate Pi processes. They do not create Git worktrees automatically; choose a working directory or worktree separately. ``` pi -e npm:pi-subagentura ``` [Repository](https://github.com/lmn451/pi-subagentura) · [Documentation (644387d5a60db88aa07f743473dbb5b1993ad013)](https://github.com/lmn451/pi-subagentura/blob/644387d5a60db88aa07f743473dbb5b1993ad013/README.md) ### HazAT/pi-interactive-subagents **Good fit** Asynchronous specialist panes, reusable agent definitions, and bundled planning and iteration flows. **Requirements and tradeoffs** Pi must run inside cmux, tmux, Zellij, or WezTerm; agent behavior and defaults are configured through agent files. **Interaction** A live widget tracks pane status; interrupt active turns, resume prior sessions, or work directly in a child pane. **Context and continuation** Standalone starts fresh by default; `fork: true` seeds the child with the caller's conversation. Resuming continues its saved session. **Process and workspace** Each child runs in a dedicated multiplexer pane, with a configurable working directory such as an agent role folder. ``` pi install git:github.com/HazAT/pi-interactive-subagents ``` [Repository](https://github.com/HazAT/pi-interactive-subagents) · [Documentation (c100577ebf7393a11d098ad9810ec6c269dcfc30)](https://github.com/HazAT/pi-interactive-subagents/blob/c100577ebf7393a11d098ad9810ec6c269dcfc30/README.md) ### nicobailon/pi-subagents **Good fit** Broad delegation toolkit with FleetView controls, reusable workflows, and background jobs. **Requirements and tradeoffs** Requires Pi 1.2.0 or newer; includes workflow, schedule, watchdog, and external-runner features alongside delegation. **Interaction** Foreground children stream in the parent TUI; background runs stay visible in FleetView, where you can inspect, steer, or stop them. **Context and continuation** Children have their own sessions. Prompts can use the current discussion; workflow results can stay outside parent context until delivery. **Process and workspace** Foreground children run in the parent Pi process, while background children use a detached runner. Optional worktree isolation is available for workflow agents. ``` pi install npm:pi-subagents ``` [Repository](https://github.com/nicobailon/pi-subagents) · [Documentation (80f8f79d51ee8075fd39baf7fe8ff36b43c3a790)](https://github.com/nicobailon/pi-subagents/blob/80f8f79d51ee8075fd39baf7fe8ff36b43c3a790/README.md) ### tintinweb/pi-subagents **Good fit** Claude Code-style agent definitions, FleetView, conversation steering, nested delegation, and scripted workflows. **Requirements and tradeoffs** Requires Pi 1.1.0 or newer. Worktree isolation is optional; model-scope enforcement is configurable. **Interaction** Manage agents in Pi's widget, fleet list, conversation viewer, or `@handle` mentions; send steering messages and resume completed sessions. **Context and continuation** Parent context can be forked into a child. Saved sessions can resume later, and agent memory supports project, local, or user scope. **Process and workspace** Optional worktree mode runs an agent in a repository copy and preserves changes on a branch; separate tool and extension policies are configurable. ``` pi install npm:@tintinweb/pi-subagents ``` [Repository](https://github.com/tintinweb/pi-subagents) · [Documentation (ca93a5247e72e7053fcd10bea7125d6c4205f949)](https://github.com/tintinweb/pi-subagents/blob/ca93a5247e72e7053fcd10bea7125d6c4205f949/README.md) ### mjakl/pi-subagent **Good fit** Markdown-defined specialists, parallel calls, streaming progress, and named continuation sessions. **Requirements and tradeoffs** Requires Pi 0.87.1 or newer; parent-local inline workers are explicitly experimental. **Interaction** Headless child processes stream progress and results through the parent Pi interface; named specialists can be called again for follow-up work. **Context and continuation** Children start fresh by default; an explicit option clones the parent's current conversation. Named sessions preserve a specialist's follow-up history. **Process and workspace** Each delegation normally runs as a child Pi process; parent-local inline workers are an experimental option. Depth and cycle guards are available. ``` pi install npm:@mjakl/pi-subagent ``` [Repository](https://github.com/mjakl/pi-subagent) · [Documentation (77cc8be9a4257c00643f328d461a7ab2c1490686)](https://github.com/mjakl/pi-subagent/blob/77cc8be9a4257c00643f328d461a7ab2c1490686/README.md) ### gotgenes/pi-subagents **Good fit** In-process child sessions with live status, agent-defined tools and models, steering, resume, and a typed extension API. **Requirements and tradeoffs** Worktree isolation is provided by the separate @gotgenes/pi-subagents-worktrees package. **Interaction** Foreground results stream inline; a persistent widget tracks background agents. Use steering tools to redirect a run and a read-only viewer for transcripts. **Context and continuation** Each agent has its own session context. Parent-context inheritance is optional, and completed sessions can be resumed from their transcripts. **Process and workspace** Nested Pi AgentSession instances run in the host process; the companion worktrees package can provide Git workspace isolation. ``` pi install npm:@gotgenes/pi-subagents ``` [Repository](https://github.com/gotgenes/pi-packages) · [Documentation (41405de895fb53f802df89f8978456cd1dae397e)](https://github.com/gotgenes/pi-packages/blob/41405de895fb53f802df89f8978456cd1dae397e/packages/pi-subagents/README.md) ### Integralist/pi-subagents **Good fit** In-process specialists with live full-screen transcript controls, direct @mentions, and reusable Markdown agent files. **Requirements and tradeoffs** Child sessions load without extension tools, which prevents nested subagents. **Interaction** Navigate the live agent list, inspect and steer a full-screen child conversation, and message or resume a named agent with `@handle`. **Context and continuation** A child has its own prompt and context window; persistent transcript files let a resumed agent continue its conversation history. **Process and workspace** Subagents are nested Pi AgentSession instances inside the host process, not spawned child processes. ``` pi install git:github.com/Integralist/pi-subagents ``` [Repository](https://github.com/Integralist/pi-subagents) · [Documentation (37e9c2a02873bd9733971bd529f12e53d9d40112)](https://github.com/Integralist/pi-subagents/blob/37e9c2a02873bd9733971bd529f12e53d9d40112/README.md) ### AlexParamonov/pi-subagents-lite **Good fit** Four tools for foreground and background agents, steering and continuation, custom models, and worktree targets. **Requirements and tradeoffs** Requires Pi trust approval for some cross-repository worktree targets; the default system-prompt mode replaces the parent's prompt. **Interaction** A live widget and conversation viewer show agent activity; use `/agents` to steer, continue settled agents, stop runs, or spawn manually. **Context and continuation** Prompt mode is configurable as replace, inherit, or custom. AGENTS.md context files load by default. **Process and workspace** `worktree_path` targets an existing checkout or linked worktree, including another repository subject to Pi's project-trust rules. ``` pi install npm:pi-subagents-lite ``` [Repository](https://github.com/AlexParamonov/pi-subagents-lite) · [Documentation (0a3fb576416398995d82ebc6ecd7f1cb5b5ea2de)](https://github.com/AlexParamonov/pi-subagents-lite/blob/0a3fb576416398995d82ebc6ecd7f1cb5b5ea2de/README.md) ## Ask these questions before you install. - **Where will you intervene?** Opening a terminal pane, steering from a transcript viewer, and sending another tool call are different ways to continue a task. Try the path you will use most. - **Which context should a child receive?** A fresh session, a fork of the conversation, and an explicit handoff make different information available. Check defaults as well as optional modes. - **Can two agents edit safely?** A separate process does not imply a separate checkout. Confirm whether the extension creates a worktree, uses an existing path, or shares the parent’s working directory. - **What survives the parent?** Continuation within one session and recovery after restarting Pi are separate capabilities. Read the lifecycle rules before relying on saved work. - **How much coordination do you need?** A focused delegation tool can be enough for one review. Reusable workflows, nested agents, schedules, and fleet controls add capabilities to configure and supervise. For peer sessions working as a team, also see [pi-messenger](https://github.com/nicobailon/pi-messenger) . Its shared-workspace messaging and coordination address a related need; it is not included in the parent-to-subagent comparison above. **Scope and disclosure.** The page is published by the pi-subagentura maintainer, so one listed project is the publisher’s own. Each documentation link is pinned to the audited commit, including the README from the pi-subagentura v4.0.1 source commit. The audit reads project-published sources; it does not test the extensions or certify that every described behavior works in every environment. Recheck the selected project’s current release notes and Pi requirements before installing. The table is categorical and does not rank projects. ## Try a workflow you can inspect. For pi-subagentura, start with the [installation guide](https://subagentura.tech/pi-subagentura/guides/install/) , then [open specialists in tmux or Zellij](https://subagentura.tech/pi-subagentura/guides/terminal-sessions/) . The [parallel code review guide](https://subagentura.tech/pi-subagentura/guides/parallel-code-review/) gives two specialists distinct scopes and shows how to follow up on their findings. [Watch the recorded workflow](https://subagentura.tech/pi-subagentura/watch/) to see the extension operating in Pi before you try it. --- Source: https://subagentura.tech/pi-subagentura/guides/ [pi-subagentura](https://subagentura.tech/pi-subagentura/) # Pi subagent guides. Install the extension, open a specialist’s terminal, and try a review with two focused agents. Each guide explains the setup and the decisions you control. - ## [Install Pi subagents](https://subagentura.tech/pi-subagentura/guides/install/) Check prerequisites, try pi-subagentura for one session, and choose a global or project installation. [Read guide](https://subagentura.tech/pi-subagentura/guides/install/) - ## [Use Pi subagents in tmux or Zellij](https://subagentura.tech/pi-subagentura/guides/terminal-sessions/) Launch visible specialists, inspect their terminals, attach, and continue the same conversation. [Read guide](https://subagentura.tech/pi-subagentura/guides/terminal-sessions/) - ## [Run a parallel code review](https://subagentura.tech/pi-subagentura/guides/parallel-code-review/) Give two specialists separate review scopes, collect evidence, and follow up on their findings. [Read guide](https://subagentura.tech/pi-subagentura/guides/parallel-code-review/) - ## [Prompts, context, and recovery FAQ](https://subagentura.tech/pi-subagentura/guides/faq/) Understand in-process delegation, terminal sessions, parent recovery, worktrees, costs, and telemetry. [Read guide](https://subagentura.tech/pi-subagentura/guides/faq/) Still choosing an extension? [Compare eight Pi subagent projects](https://subagentura.tech/pi-subagentura/compare/) by interaction, context, and workspace behavior. [Watch the recorded workflow](https://subagentura.tech/pi-subagentura/watch/) for a view of pi-subagentura running in a real tmux session, with an English transcript. --- Source: https://subagentura.tech/pi-subagentura/guides/faq/ # Pi subagent questions, answered. Know what runs where, what you control, and what survives the parent session before delegating a real task. By [lmn451](https://github.com/lmn451) · Updated 7 November 2026 [Compare Pi extensions](https://subagentura.tech/pi-subagentura/compare/) These answers describe pi-subagentura v4.2.1. The [released README](https://github.com/lmn451/pi-subagentura/blob/v4.2.1/README.md) and [telemetry contract](https://github.com/lmn451/pi-subagentura/blob/v4.2.1/docs/telemetry.md) are the primary references. ## What is pi-subagentura? pi-subagentura is an open-source extension for the Pi coding agent. It provides in-process delegation, attachable child Pi sessions, progress and result tools, and reusable workflows. You supply your specialist prompts and choose models configured in Pi. ## Can subagents run in-process without tmux? Yes. The subagent_with_context and subagent_isolated tools run inside the parent Pi runtime, with inherited or fresh conversation context. They do not open attachable terminals. Interactive child sessions run as separate Pi processes and require tmux, Zellij, or Herdr. ## Can I keep my own agent prompts and models? Yes. Ask the parent to read a selected specialist prompt and pass it as the child's persona. Use --append-system-prompt for your coordination instructions, supplied as text or a file. A prompt folder is not imported automatically. The extension uses your configured Pi models and provider authentication. ## Do I have to use Orchestratorv2? No. Direct delegation works without an orchestration flag. --orchestratorv2 adds optional system-prompt guidance for routing work to attachable specialists. --orchestrator is the workflow-oriented mode. These prompts guide the model; they do not enforce a tool permission or approval boundary. ## What survives a Pi restart or reload? Standalone interactive children and their artifact-backed state can be recovered when continuing the matching parent session after reload, resume, or quit. A fresh new or fork transition cleans up owned interactive work. In-process jobs and background workflows are parent-session scoped and are retired during session replacement. ## Does a separate child session isolate Git changes? No. A separate Pi process does not automatically create a Git worktree. Choose a separate checkout or worktree and pass its working directory when agents need independent files. In-process execution and the workflow VM are not security sandboxes. ## Is pi-subagentura free, and what does it send? The extension is MIT licensed and free to install. Model usage is billed by your configured provider. Anonymous product telemetry is enabled by default; launch with --no-subagentura-telemetry to opt out. The repository's telemetry documentation defines the collected fields and other opt-out settings. ## Try it with a focused task. Start with the [installation guide](https://subagentura.tech/pi-subagentura/guides/install/) , then follow the [parallel code review walkthrough](https://subagentura.tech/pi-subagentura/guides/parallel-code-review/) . Still evaluating options? Read the [source-linked comparison of eight Pi extensions](https://subagentura.tech/pi-subagentura/compare/) . --- Source: https://subagentura.tech/pi-subagentura/guides/install/ # Install pi-subagentura Install the Pi extension globally, for one project, or temporarily for one run. Interactive child sessions also need tmux, Zellij, or Herdr. By [lmn451](https://github.com/lmn451) · Updated 7 November 2026 [Compare Pi extensions](https://subagentura.tech/pi-subagentura/compare/) ## Check the requirements This guide covers the published pi-subagentura 4.2.1release; package metadata was verified 2026-11-07. Its Pi SDK peer packages (`@earendil-works/pi-agent-core`,`@earendil-works/pi-ai`, `@earendil-works/pi-coding-agent`, and `@earendil-works/pi-tui`) must be version 1.2.0 or newer. The `typebox` peer must be at least 1.1.38 and below 2; Node.js must be 22.23.2 or newer. See the[v4.2.1 package.json](https://github.com/lmn451/pi-subagentura/blob/v4.2.1/package.json) or [npm release metadata](https://www.npmjs.com/package/pi-subagentura/v/4.2.1) . Interactive subagents need a supported terminal multiplexer: tmux, Zellij, or Herdr. You can still install the extension without a multiplexer, but the interactive pane workflow needs one available. The extension provides both interactive child sessions and lighter in-process delegation tools. This install guide focuses on getting the extension loaded; no Orchestratorv2 or workflow mode is required to begin. ## Choose an install scope Use the scope that matches how you work with Pi. The unversioned commands below select the latest npm release, which may be newer than this guide. ### Install for all Pi projects Run this once to make the extension available in your normal Pi sessions: ``` pi install npm:pi-subagentura ``` ### Install for the current project From the project directory, use Pi’s local install option. This keeps the extension associated with that project rather than adding it to your global Pi setup. ``` pi install -l npm:pi-subagentura ``` ### Try it for one Pi run To test the package without making a persistent install, launch Pi with the extension enabled for that run: ``` pi -e npm:pi-subagentura ``` To try the exact release documented here, specify its version: ``` pi -e npm:pi-subagentura@4.2.1 ``` These commands install or load the extension. They do not automatically start a specialist. Once Pi is running, you can ask it to use an interactive subagent for a focused task. ## Ask for one focused session For a first check, try a small inspection request. This is an example prompt, not a claim that a session has already run: ``` Open one interactive specialist to inspect the project’s top-level structure. Ask it to report the main application entry point and one relevant file. Keep the session available so I can ask a follow-up. ``` The parent Pi agent decides how to handle the request. The extension also supports direct tool use and optional Orchestratorv2 routing; neither is required for the commands above. For the terminal setup and how to make a child pane visible, continue to the [terminal sessions guide](https://subagentura.tech/pi-subagentura/guides/terminal-sessions/) . ## If it does not load - Confirm the Pi SDK peer packages are at least 1.2.0 and `typebox` is at least 1.1.38 and below 2. - Confirm Node.js is at least 22.23.2. - For interactive children, confirm tmux, Zellij, or Herdr is installed and available to the Pi process. A plain in-process delegation tool does not open a terminal pane. - If the request depends on current conversation details, include those details in the task or ask Pi to pass the parent context to the child. Interactive children otherwise have their own Pi session context. See the [product overview](https://subagentura.tech/pi-subagentura/) , the[session walkthrough](https://subagentura.tech/pi-subagentura/watch/) , or the[Pi subagents overview](https://subagentura.tech/pi-subagentura/compare/) . Next guides:[tmux and Zellij sessions](https://subagentura.tech/pi-subagentura/guides/terminal-sessions/) and [parallel code review](https://subagentura.tech/pi-subagentura/guides/parallel-code-review/) . [Published package README](https://github.com/lmn451/pi-subagentura/blob/v4.2.1/README.md) · [npm release details](https://www.npmjs.com/package/pi-subagentura) --- Source: https://subagentura.tech/pi-subagentura/guides/parallel-code-review/ # Run parallel code reviews with Pi subagents Split a review into independent frontend and backend scopes, ask for findings with file and line evidence, and keep each interactive reviewer available for follow-up. By [lmn451](https://github.com/lmn451) · Updated 7 November 2026 [Compare Pi extensions](https://subagentura.tech/pi-subagentura/compare/) ## Give each reviewer a distinct scope Parallel review is most useful when each Pi child has a clear boundary. For example, one specialist can inspect UI behavior and another can trace API or persistence behavior. Share the commit or diff to review, identify excluded files, and ask both reviewers to return findings rather than broad summaries. Their separate session contexts make follow-up possible without asking the same questions from scratch. First inspect your current changes and working tree so you know what is being reviewed. The child sessions use the project directory by default; pi-subagentura does not create a separate Git worktree automatically. If both scopes touch the same files, make that overlap explicit. ## Launch two focused reviewers Ask the parent Pi agent to start two interactive children concurrently. Set `background: false` on each call if you want to watch both in visible panes. If the review depends on decisions in the current parent conversation, pass that context with `includeContext: true`; otherwise include the necessary review brief in each task. The following task prompts are examples to adapt, not completed reviews: ### Frontend reviewer example ``` Review the changed frontend routes and components in this diff. Stay within the UI scope: look for behavior regressions, accessibility issues, and mismatches between visible controls and their actual behavior. Do not edit or format files. Return only actionable findings with severity, file and line, impact, and specific evidence. If you find none, say so. ``` ### Backend reviewer example ``` Review the changed API, data, and server-side code in this diff. Stay within the backend scope: trace inputs through validation and persistence, and look for correctness or error-handling gaps. Do not edit or format files. Return only actionable findings with severity, file and line, impact, and specific evidence. If you find none, say so. ``` Two calls to `subagent_interactive` let the parent keep both reviews inspectable as they work. These are separate Pi processes, so starting the second does not require waiting for the first to finish. The parent remains responsible for comparing their findings and deciding which points to investigate. ## A read-only request is still a request “Do not edit” in a task prompt or persona is guidance for the model, not an enforced tool-permission boundary. pi-subagentura does not automatically import arbitrary agent-definition files or tool allowlists into the child. A child may have tools capable of changing files, depending on the Pi environment and extensions you use. Both reviewers also share the parent project working directory by default. A separate child process does not mean a separate checkout: changes made by one child can be visible to the other. If the review must remain read-only, check `git status` before and after, inspect the diff for unexpected edits, and handle any required isolation separately. ## Ask for evidence, then follow up in the same session Prefer findings with a concrete file and line, a user or system impact, and evidence from the code path. If a report is unclear, send a follow-up to that same interactive child to check the specific path or explain why the behavior is a defect. The child keeps its own conversation context across follow-ups; it does not need the parent to repeat its entire task. The parent should still verify important findings before acting on them. Open `/subagents` or press `Ctrl+Alt+A` to inspect the reviewers; `v` captures a terminal snapshot,`f` focuses a pane, and `a` displays its attach command. See the [install guide](https://subagentura.tech/pi-subagentura/guides/install/) or [tmux and Zellij guide](https://subagentura.tech/pi-subagentura/guides/terminal-sessions/) for setup and lifecycle details. Read the [released README](https://github.com/lmn451/pi-subagentura/blob/v4.2.1/README.md) for supported tool behavior. Continue to the [product overview](https://subagentura.tech/pi-subagentura/) ,[session walkthrough](https://subagentura.tech/pi-subagentura/watch/) , or[Pi subagents overview](https://subagentura.tech/pi-subagentura/compare/) . This tutorial describes pi-subagentura 4.2.1; package metadata was verified 2026-11-07. The prompts are examples, not reports of completed reviews. --- Source: https://subagentura.tech/pi-subagentura/guides/terminal-sessions/ # Run Pi subagents in tmux or Zellij Start Pi inside a named terminal session, choose a visible child pane, and use the supervisor to inspect, focus, attach, and continue interactive work. By [lmn451](https://github.com/lmn451) · Updated 7 November 2026 [Compare Pi extensions](https://subagentura.tech/pi-subagentura/compare/) ## Start Pi inside a named terminal session Interactive subagents run as separate Pi processes in multiplexer panes. Start the parent Pi session from the project directory where you want the child to work. These instructions cover published pi-subagentura4.2.1; package metadata was verified2026-11-07. Install it first, then use one of these examples. ### tmux ``` cd /path/to/project tmux new -s pi-lab ``` The `tmux new -s` command creates a named session and attaches your terminal to it. At the shell prompt inside tmux, start Pi: ``` pi ``` To return to that session later, run `tmux attach -t pi-lab`. ### Zellij ``` cd /path/to/project zellij --session-name pi-lab ``` At the shell prompt inside Zellij, start Pi: ``` pi ``` To attach later, use `zellij attach pi-lab`. These commands only start the terminal environment and Pi; they do not spawn a child by themselves. For a temporary one-session install, launch Pi with`pi -e npm:pi-subagentura` instead. [tmux session guide](https://github.com/tmux/tmux/wiki/Getting-Started) · [Zellij command-line options](https://zellij.dev/documentation/command-line-options.html) · [Zellij attach command](https://zellij.dev/documentation/commands) ## Open a visible interactive child Once the parent Pi session is running inside tmux or Zellij, ask Pi to start an interactive specialist for a focused task. For example: ``` Start an interactive specialist to inspect the routing code. Open it in a visible pane, summarize the files it plans to inspect, and keep the session open for a follow-up. ``` When Pi calls `subagent_interactive`, set its`background` option to `false` for a side-by-side pane. The option defaults to `true`, which opens a detached named window or tab; it does not appear beside the parent until you focus or attach to it. The tool selects the active tmux or Zellij environment automatically. You do not need to pass a multiplexer startup flag. If you launch the parent outside a multiplexer, the child can start in a detached session and return an attach command. The command returned by the tool is the reliable way to connect to that child; it includes the target session or terminal identifier. ## Inspect, focus, attach, and continue Open `/subagents` in Pi, or press `Ctrl+Alt+A`, to see async work and interactive children. Select a child and expand its details before using the interactive controls: - `v` captures a bounded terminal snapshot. - `f` focuses the child pane in the current multiplexer. - `a` shows the terminal-scoped attach command. - `X` cancels the selected child and its descendant subtree. You can also ask the parent Pi agent to send the child a follow-up. The follow-up continues that child Pi session with its existing conversation context. Terminal input is another option: focus or attach to the child and type directly into its Pi prompt. See the [package README’s interactive subagent section](https://github.com/lmn451/pi-subagentura/blob/v4.2.1/README.md) for the tool behavior and supervisor controls. ## Know which context continues An interactive child has its own Pi session. If you want it to see the parent conversation branch at launch, Pi can pass that context explicitly with the tool’s `includeContext` option. Otherwise, give the child the task details it needs; do not assume it has the parent’s full transcript. A follow-up sent to the same child continues the child’s own conversation. Interactive child panes and their artifacts can rehydrate across reload, resume, and quit continuity transitions when you return to the matching parent session. Starting a fresh `/new` or `/fork`cleans up the interactive work owned by that previous session. In-process jobs and background workflows have different, session-scoped lifecycles. The child uses the project working directory by default; pi-subagentura does not create a Git worktree for it automatically. Continue with the [install guide](https://subagentura.tech/pi-subagentura/guides/install/) or [parallel review tutorial](https://subagentura.tech/pi-subagentura/guides/parallel-code-review/) . See also the [product overview](https://subagentura.tech/pi-subagentura/) ,[session walkthrough](https://subagentura.tech/pi-subagentura/watch/) , and[Pi subagents overview](https://subagentura.tech/pi-subagentura/compare/) . --- Source: https://subagentura.tech/pi-subagentura/statistics-2026/ # Pi subagent statistics 2026: an eight-extension study. A compact census of what eight selected Pi subagent projects document about execution, terminal access, and Git workspaces. Every record links to the exact source revision reviewed. By [lmn451](https://github.com/lmn451) · Updated 21 October 2026 [Setup and workflow guides](https://subagentura.tech/pi-subagentura/guides/) ## What do Pi subagent extensions document in 2026? This 2026 study contains 8 selected Pi subagent extension records in the [JSON dataset](https://subagentura.tech/pi-subagentura/statistics-2026/data.json) and [CSV dataset](https://subagentura.tech/pi-subagentura/statistics-2026/data.csv) ; each row links to the pinned README or primary documentation revision reviewed on 2026-10-21. It counts documented mechanisms in this selection; it is not a market-size estimate, adoption survey, performance test, or complete directory. Use the [full Pi subagent comparison](https://subagentura.tech/pi-subagentura/compare/) for context, installation commands, and detailed project profiles. The [pi-subagentura npm and GitHub statistics](https://subagentura.tech/pi-subagentura/stats/) are a separate dataset about one project's public service counters. Download the original census: [JSON dataset](https://subagentura.tech/pi-subagentura/statistics-2026/data.json) · [CSV dataset](https://subagentura.tech/pi-subagentura/statistics-2026/data.csv) . ## How many Pi subagent extensions document in-process execution in 2026? 6 of 8 selected Pi subagent extensions document standard in-process child execution in their reviewed 2026 sources: [lmn451/pi-subagentura](https://github.com/lmn451/pi-subagentura/blob/644387d5a60db88aa07f743473dbb5b1993ad013/README.md) ; [nicobailon/pi-subagents](https://github.com/nicobailon/pi-subagents/blob/80f8f79d51ee8075fd39baf7fe8ff36b43c3a790/README.md) ; [tintinweb/pi-subagents](https://github.com/tintinweb/pi-subagents/blob/ca93a5247e72e7053fcd10bea7125d6c4205f949/README.md) ; [gotgenes/pi-subagents](https://github.com/gotgenes/pi-packages/blob/41405de895fb53f802df89f8978456cd1dae397e/packages/pi-subagents/README.md) ; [Integralist/pi-subagents](https://github.com/Integralist/pi-subagents/blob/37e9c2a02873bd9733971bd529f12e53d9d40112/README.md) ; [AlexParamonov/pi-subagents-lite](https://github.com/AlexParamonov/pi-subagents-lite/blob/0a3fb576416398995d82ebc6ecd7f1cb5b5ea2de/README.md) . 1 of 8 selected extensions documents an experimental parent-local inline-worker path in its 2026 source, while describing separate Pi processes as the normal delegation mode: [mjakl/pi-subagent](https://github.com/mjakl/pi-subagent/blob/77cc8be9a4257c00643f328d461a7ab2c1490686/README.md) . 1 of 8 selected extensions has no in-process execution path documented in the reviewed 2026 source; that source describes Pi sessions in multiplexer panes: [HazAT/pi-interactive-subagents](https://github.com/HazAT/pi-interactive-subagents/blob/c100577ebf7393a11d098ad9810ec6c269dcfc30/README.md) . [Permalink to this finding](https://subagentura.tech/pi-subagentura/statistics-2026/#in-process-statistics-2026) · Reviewed 2026-10-21 ## How many Pi subagent extensions document attachable terminals in 2026? 2 of 8 selected Pi subagent extensions explicitly document attachable child-terminal sessions in their 2026 sources: [lmn451/pi-subagentura](https://github.com/lmn451/pi-subagentura/blob/644387d5a60db88aa07f743473dbb5b1993ad013/README.md) ; [HazAT/pi-interactive-subagents](https://github.com/HazAT/pi-interactive-subagents/blob/c100577ebf7393a11d098ad9810ec6c269dcfc30/README.md) . “Not documented” in the table means the reviewed source did not explicitly describe entering an attachable child terminal; it does not establish that a project cannot support one. [Permalink to this finding](https://subagentura.tech/pi-subagentura/statistics-2026/#terminal-statistics-2026) · Reviewed 2026-10-21 ## Which Pi subagent projects document Git worktree support in 2026? 2 of 8 selected Pi subagent extensions document built-in or workflow worktree creation in 2026: [nicobailon/pi-subagents](https://github.com/nicobailon/pi-subagents/blob/80f8f79d51ee8075fd39baf7fe8ff36b43c3a790/README.md) ; [tintinweb/pi-subagents](https://github.com/tintinweb/pi-subagents/blob/ca93a5247e72e7053fcd10bea7125d6c4205f949/README.md) . 1 of 8 selected extensions documents worktree creation through a companion package in its 2026 source: [gotgenes/pi-subagents](https://github.com/gotgenes/pi-packages/blob/41405de895fb53f802df89f8978456cd1dae397e/packages/pi-subagents/README.md) . 1 of 8 selected extensions documents targeting an existing checkout or linked worktree path in 2026: [AlexParamonov/pi-subagents-lite](https://github.com/AlexParamonov/pi-subagents-lite/blob/0a3fb576416398995d82ebc6ecd7f1cb5b5ea2de/README.md) . 4 of 8 selected extensions have no worktree-creation or existing-path mechanism classified in their reviewed 2026 documentation: [lmn451/pi-subagentura](https://github.com/lmn451/pi-subagentura/blob/644387d5a60db88aa07f743473dbb5b1993ad013/README.md) ; [HazAT/pi-interactive-subagents](https://github.com/HazAT/pi-interactive-subagents/blob/c100577ebf7393a11d098ad9810ec6c269dcfc30/README.md) ; [mjakl/pi-subagent](https://github.com/mjakl/pi-subagent/blob/77cc8be9a4257c00643f328d461a7ab2c1490686/README.md) ; [Integralist/pi-subagents](https://github.com/Integralist/pi-subagents/blob/37e9c2a02873bd9733971bd529f12e53d9d40112/README.md) . This category records the scope of the sources reviewed; it is not a claim that those projects cannot be used with a separately chosen checkout. [Permalink to this finding](https://subagentura.tech/pi-subagentura/statistics-2026/#worktree-statistics-2026) · Reviewed 2026-10-21 ## Which terminal environments do Pi subagent projects name in 2026? The 2026 documentation for 8 selected Pi subagent extensions names 5 supported terminal or multiplexer environments across 2 projects: cmux, Herdr, tmux, WezTerm, Zellij. The supporting source revisions are [lmn451/pi-subagentura](https://github.com/lmn451/pi-subagentura/blob/644387d5a60db88aa07f743473dbb5b1993ad013/README.md) ; [HazAT/pi-interactive-subagents](https://github.com/HazAT/pi-interactive-subagents/blob/c100577ebf7393a11d098ad9810ec6c269dcfc30/README.md) . [Permalink to this finding](https://subagentura.tech/pi-subagentura/statistics-2026/#terminal-environment-statistics-2026) · Reviewed 2026-10-21 ## Which eight Pi subagent projects are in this 2026 study? Each row records how the reviewed source describes the project; the linked revision is the evidence for that row. A “not-documented” value marks an evidence limit, not a negative feature claim. Scroll horizontally on narrow screens to read all source-pinned classification columns. | Project | In-process execution | Attachable child terminal documented | Worktree approach | Terminal environments named | Reviewed source | | --- | --- | --- | --- | --- | --- | | lmn451/pi-subagentura | standard | Documented | not-documented | tmux, Zellij, Herdr | [644387d5a60db88aa07f743473dbb5b1993ad013](https://github.com/lmn451/pi-subagentura/blob/644387d5a60db88aa07f743473dbb5b1993ad013/README.md) | | HazAT/pi-interactive-subagents | not-documented | Documented | not-documented | cmux, tmux, Zellij, WezTerm | [c100577ebf7393a11d098ad9810ec6c269dcfc30](https://github.com/HazAT/pi-interactive-subagents/blob/c100577ebf7393a11d098ad9810ec6c269dcfc30/README.md) | | nicobailon/pi-subagents | standard | Not documented | built-in-or-workflow | Not documented | [80f8f79d51ee8075fd39baf7fe8ff36b43c3a790](https://github.com/nicobailon/pi-subagents/blob/80f8f79d51ee8075fd39baf7fe8ff36b43c3a790/README.md) | | tintinweb/pi-subagents | standard | Not documented | built-in-or-workflow | Not documented | [ca93a5247e72e7053fcd10bea7125d6c4205f949](https://github.com/tintinweb/pi-subagents/blob/ca93a5247e72e7053fcd10bea7125d6c4205f949/README.md) | | mjakl/pi-subagent | experimental | Not documented | not-documented | Not documented | [77cc8be9a4257c00643f328d461a7ab2c1490686](https://github.com/mjakl/pi-subagent/blob/77cc8be9a4257c00643f328d461a7ab2c1490686/README.md) | | gotgenes/pi-subagents | standard | Not documented | companion | Not documented | [41405de895fb53f802df89f8978456cd1dae397e](https://github.com/gotgenes/pi-packages/blob/41405de895fb53f802df89f8978456cd1dae397e/packages/pi-subagents/README.md) | | Integralist/pi-subagents | standard | Not documented | not-documented | Not documented | [37e9c2a02873bd9733971bd529f12e53d9d40112](https://github.com/Integralist/pi-subagents/blob/37e9c2a02873bd9733971bd529f12e53d9d40112/README.md) | | AlexParamonov/pi-subagents-lite | standard | Not documented | existing-path | Not documented | [0a3fb576416398995d82ebc6ecd7f1cb5b5ea2de](https://github.com/AlexParamonov/pi-subagents-lite/blob/0a3fb576416398995d82ebc6ecd7f1cb5b5ea2de/README.md) | Machine-readable files: [JSON dataset](https://subagentura.tech/pi-subagentura/statistics-2026/data.json) · [CSV dataset](https://subagentura.tech/pi-subagentura/statistics-2026/data.csv) . [Data dictionary, scope, and publisher disclosure](https://subagentura.tech/pi-subagentura/statistics-2026/data-dictionary.txt) accompanies both formats; every CSV record includes its metadata URL. ## How was the 2026 Pi subagent documentation study assembled? The 8-project sample is purposive: it consists of the eight projects selected for the companion comparison, rather than a random or exhaustive sample of Pi extensions. The publisher of this study also publishes pi-subagentura, which is included in the sample; that is a direct conflict of interest. Each classification was transcribed from the source revision linked in its row and reviewed 2026-10-21. Git commit hashes pin every source, including the npm v4.0.1 source commit for pi-subagentura; a README can describe repository code that is newer than the latest package available from a package registry. “Standard” means the source describes in-process child execution as an ordinary supported path. “Experimental” preserves the source’s explicit experimental label. A boolean terminal value is positive only when an attachable terminal is explicitly documented; “not documented” is not treated as “unsupported.” Worktree categories distinguish built-in or workflow creation, a companion package, and an explicitly documented worktree-path control. Generic working-directory overrides such as pi-subagentura’s cwd are not counted as a dedicated worktree feature; they can still point to a checkout the caller prepared. The counts describe documentation in this selected sample as of the review date. They do not estimate extension market share, usage, project quality, performance, reliability, or the full set of available Pi tools. For citation, link to [Pi subagent extension documentation census, 2026](https://subagentura.tech/pi-subagentura/statistics-2026/) and include the review date, 2026-10-21. Download the [JSON dataset](https://subagentura.tech/pi-subagentura/statistics-2026/data.json) or [CSV dataset](https://subagentura.tech/pi-subagentura/statistics-2026/data.csv) to inspect each classification and its pinned source. --- Source: https://subagentura.tech/pi-subagentura/stats/ # Pi-subagentura download statistics 2026 A dated snapshot of npm download requests and GitHub repository signals, with exact periods, source links, a daily series, and an explanation of what each counter can show. By [lmn451](https://github.com/lmn451) · Updated 21 October 2026 [Compare Pi extensions](https://subagentura.tech/pi-subagentura/compare/) ## Pi-subagentura download statistics 2026 Four source-linked observations from npm and GitHub. npm's counts are package download requests, including CI and repeat downloads; they do not count unique people. - npm recorded 1,576 download requests for pi-subagentura from 19 September 2026 through 18 October 2026 (inclusive). [Source: npm Downloads API](https://api.npmjs.org/downloads/point/2026-09-19:2026-10-18/pi-subagentura) [Permalink ↗](https://subagentura.tech/pi-subagentura/stats/#npm-downloads-30-days-2026) - npm recorded 571 download requests for pi-subagentura from 12 October 2026 through 18 October 2026 (inclusive). [Source: npm Downloads API](https://api.npmjs.org/downloads/point/2026-10-12:2026-10-18/pi-subagentura) [Permalink ↗](https://subagentura.tech/pi-subagentura/stats/#npm-downloads-7-days-2026) - The public GitHub API snapshot for lmn451/pi-subagentura recorded 14 stars on 21 October 2026. [Source: GitHub repository API](https://api.github.com/repos/lmn451/pi-subagentura) · [Dated snapshot data](https://subagentura.tech/pi-subagentura/stats.json) [Permalink ↗](https://subagentura.tech/pi-subagentura/stats/#github-stars-2026-10-21) - The public GitHub API snapshot for lmn451/pi-subagentura recorded 6 forks on 21 October 2026. [Source: GitHub repository API](https://api.github.com/repos/lmn451/pi-subagentura) · [Dated snapshot data](https://subagentura.tech/pi-subagentura/stats.json) [Permalink ↗](https://subagentura.tech/pi-subagentura/stats/#github-forks-2026-10-21) Suggested citation: subagentura, “Pi-subagentura download statistics 2026,” snapshot captured 21 October 2026. [Citation URL: subagentura.tech/pi-subagentura/stats/#download-statistics-2026](https://subagentura.tech/pi-subagentura/stats/#download-statistics-2026) ## Distribution and repository signals npm reports package download requests. GitHub reports current repository counters at snapshot time. npm download reporting can lag, and historical counts can change after collection. The dates below are the 30-day period returned by npm when this snapshot was collected. Source links show the provider's current response; use the [saved JSON snapshot](https://subagentura.tech/pi-subagentura/stats.json) to reproduce the figures shown here. Snapshot captured 2026-10-21 15:48:43 UTC. **npm downloads · last 30 days** 1,576 2026-09-19 through 2026-10-18 · inclusive[Open npm API result](https://api.npmjs.org/downloads/point/2026-09-19:2026-10-18/pi-subagentura) **npm downloads · last 7 days** 571 2026-10-12 through 2026-10-18 · inclusive[Open npm API result](https://api.npmjs.org/downloads/point/2026-10-12:2026-10-18/pi-subagentura) **GitHub stars** 14 At 2026-10-21 snapshot time[View repository](https://github.com/lmn451/pi-subagentura/stargazers) **GitHub forks** 6 At 2026-10-21 snapshot time[View repository](https://github.com/lmn451/pi-subagentura/forks) npm release in this snapshot **v4.0.1**Published 2026-10-18 [Source revision 644387d5a60d…](https://github.com/lmn451/pi-subagentura/tree/644387d5a60db88aa07f743473dbb5b1993ad013) ## Thirty days, one row at a time 2026-09-19 to 2026-10-18. Each bar represents the npm API's download-request count for that UTC date. DOWNLOAD REQUESTS / DAY MAX 248 Zero means the npm range endpoint returned zero for that date at collection time; historical counts may later change. Values count requests, including automated and repeat downloads. | Date (UTC) | Download requests | | --- | --- | | 2026-09-19 | 11 | | 2026-09-20 | 54 | | 2026-09-21 | 13 | | 2026-09-22 | 20 | | 2026-09-23 | 25 | | 2026-09-24 | 163 | | 2026-09-25 | 197 | | 2026-09-26 | 50 | | 2026-09-27 | 20 | | 2026-09-28 | 121 | | 2026-09-29 | 61 | | 2026-09-30 | 37 | | 2026-10-01 | 37 | | 2026-10-02 | 26 | | 2026-10-03 | 50 | | 2026-10-04 | 11 | | 2026-10-05 | 26 | | 2026-10-06 | 0 | | 2026-10-07 | 16 | | 2026-10-08 | 19 | | 2026-10-09 | 16 | | 2026-10-10 | 17 | | 2026-10-11 | 15 | | 2026-10-12 | 17 | | 2026-10-13 | 0 | | 2026-10-14 | 0 | | 2026-10-15 | 0 | | 2026-10-16 | 105 | | 2026-10-17 | 201 | | 2026-10-18 | 248 | [Open the current npm API response for this 30-day period](https://api.npmjs.org/downloads/range/2026-09-19:2026-10-18/pi-subagentura) ## What the counters do and do not say These figures describe public service counters at a recorded time. They are not a measure of how many people use the project. **npm downloads** Counts package download requests served by npm in the stated inclusive date range. It includes CI installs, mirrors, and repeat downloads. It cannot identify unique people, active installations, or adoption. **GitHub stars and forks** Repository counters read from GitHub's public repository API when the snapshot is fetched. They are point-in-time totals, not activity over the npm date range. **Refresh and reproducibility** This page uses a checked-in JSON snapshot, so the site build does not make live API calls. The data file records its collection time, source URLs, periods, release version, and daily series. [PACKAGE npm · pi-subagentura](https://www.npmjs.com/package/pi-subagentura) [REPOSITORY GitHub · lmn451/pi-subagentura](https://github.com/lmn451/pi-subagentura) [RELEASE METADATA npm registry](https://registry.npmjs.org/pi-subagentura) [SNAPSHOT DATA Download JSON](https://subagentura.tech/pi-subagentura/stats.json) For an ecosystem-wide comparison, see the [2026 census of eight selected Pi sub-agent extensions](https://subagentura.tech/pi-subagentura/statistics-2026/) . It describes that scoped sample; it is not an exhaustive count of every extension. [Return to pi-subagentura](https://subagentura.tech/pi-subagentura/) --- Source: https://subagentura.tech/pi-subagentura/watch/ # Watch Pi subagents in action. A real pi-subagentura workflow in tmux. The full 97:56 session is condensed to 8:06, with quiet stretches accelerated up to 100× and English translations over the original terminal. ## The recorded workflow The complete 97:56 session plays as one chronological record, with quiet stretches accelerated up to 100×. The original terminal stays visible; English translations make the Russian status messages readable. [Watch the full workflow video](https://subagentura.tech/media/pi-subagentura/workflow.mp4) 97:56 source session · 8:06 continuous edit · waits preserved at speed [Download the English transcript](https://subagentura.tech/media/pi-subagentura/workflow.english-transcript.md) **Open the translated transcript** - Yes. I reviewed the current head of PR #166. - I started two interactive subagents on Luna/max: an implementation worker in the separate worktree/branch feat/jev-routing-provider-neutral, and an architecture reviewer in feat/decision-plan-review. They communicate through pi-intercom; after the first commit I will continue with the upper layer and link the branches through gh stack. - Understood. I will wait for the subagent notification, then verify the commit and create the stacked PRs. - The second agent has written the tests; it only found missing node_modules in the new worktree. I’m waiting for the final commit before verifying both layers. - The generic decision core is implemented and in final checks; I’m waiting for its SHA before verification and stacked PRs. - The runtime agent exited after implementation but before commit. Its worktree, commit 72ca933, src/decision/* files, tests, and package allowlist survived; a new Luna/max agent continues verification and the provider-neutral branch is clean. - Which agent exactly? The decision-runtime-core agent exited after implementation but before commit. Why was the tmux pane closed? - The process exited 0 before completion while npm test was running; no stack trace or signal is recorded, and the worktree survived. - The agent confirmed bounded diagnostics with backward compatibility and no decision-routing changes. The second agent continues hardening the generic core; both work independently. - The bounded exit metadata design is good; I requested tests for signals, malformed data, parallel starts, and legacy support. - The decision stack was created. Both PRs passed the full suite and required checks; diagnostics remains a separate fix PR. - The second agent completed and committed 59f7091. PRs #168 and #169 are clean with green CI. - I started a Luna/max agent to add the OpenRouter Decisions API adapter, shared codec, tests, and top PR in stack #170. - The OpenRouter agent confirmed the shared codec approach and explicit configuration. Work continues in the top stacked branch. - I’m waiting for the commit SHA, then I’ll verify it and add the branch as the top PR in stack #170. - The mutation pilot passed on the OpenRouter branch; the only survivor is an unrelated existing baseline. PR #172 is clean with green CI and mutation results. ## Try a session of your own. This recording was added on 18 September 2026. It shows a recorded workflow; use the current guides for setup and controls in the published extension. Start with [installation](https://subagentura.tech/pi-subagentura/guides/install/) , then [open specialists in tmux or Zellij](https://subagentura.tech/pi-subagentura/guides/terminal-sessions/) . Try a [parallel code review](https://subagentura.tech/pi-subagentura/guides/parallel-code-review/) to practice inspecting and following up on separate agents. To compare other ways of delegating in Pi, read the [Pi subagent extension comparison](https://subagentura.tech/pi-subagentura/compare/) . The [parent and child replays](https://subagentura.tech/pi-subagentura/#session-replays) provide another view of the session flow. --- Source: https://subagentura.tech/projects/ # Open-source tools Find the setup instructions, source, and demos for pi-subagentura, CSS Variables, and ScreenSilo. [Browse the directory](https://subagentura.tech/projects/#directory) [Follow on GitHub](https://github.com/lmn451) Sub-agent infrastructure for Pi ### pi-subagentura Use your own prompts and stay in charge of who does what. Tools for launching specialists, sending follow-ups, tracking progress, and collecting results. Watch or join real Pi sessions in tmux, Zellij, or Herdr. Bring your own prompts or opt into Orchestratorv2 coordination. [Try Pi subagents](https://subagentura.tech/pi-subagentura/#install) [npm package](https://www.npmjs.com/package/pi-subagentura) [Source](https://github.com/lmn451/pi-subagentura) Watch Steer Continue tmux / Zellij / Herdr CSS language intelligence ### CSS Variables Know which custom-property value wins across the whole project. Workspace-wide completion, cascade-aware hover, navigation, rename, diagnostics, and color tooling through a native Rust LSP with a TypeScript fallback. [View CSS Variables](https://subagentura.tech/css-variables/) [VS Code marketplace](https://marketplace.visualstudio.com/items?itemName=miclmn451.css-variables-vscode) [Source](https://github.com/lmn451/css-lsp-rust) VS Code Zed Rust LSP npm fallback Local screen recording ### ScreenSilo Record a walkthrough without sending it through another service. Browser capture APIs, browser-managed local storage, local preview, and WebM download with no account or upload backend. [View ScreenSilo](https://subagentura.tech/screencast/) [Chrome Web Store](https://chromewebstore.google.com/detail/screensilo/higbocdfimfmcjckomeggbbigcglpdje) [Source](https://github.com/lmn451/screencast) Chrome / Edge Firefox Local WebM ## Open-source contributions Work on independently maintained projects. Status checked 7 November 2026. ### Chrome DevTools AXI + MCP AXI shipped Streamable HTTP client support in v0.1.35 and optional navigation output without the accessibility tree in v0.1.43. The shared-session server lives in the MCP fork. Its upstream PR closed without merging. [Case study](https://subagentura.tech/contributions/chrome-devtools-axi/) [AXI repository](https://github.com/kunchenguid/chrome-devtools-axi) [MCP upstream](https://github.com/ChromeDevTools/chrome-devtools-mcp) [MCP fork](https://github.com/lmn451/chrome-devtools-mcp) **Pull requests and release evidence** [AXI transport PR](https://github.com/kunchenguid/chrome-devtools-axi/pull/139) [AXI navigation PR](https://github.com/kunchenguid/chrome-devtools-axi/pull/179) [v0.1.43 release](https://github.com/kunchenguid/chrome-devtools-axi/releases/tag/chrome-devtools-axi-v0.1.43) [MCP fork PR](https://github.com/lmn451/chrome-devtools-mcp/pull/3) [MCP upstream PR](https://github.com/ChromeDevTools/chrome-devtools-mcp/pull/2733) ### Quill An open proposal adds local transcription through Handy models you already downloaded or a configurable command. Parakeet remains the default. [Contribution notes](https://subagentura.tech/contributions/quill/) [Quill repository](https://github.com/humanitas-labs/quill) [Open PR #76](https://github.com/humanitas-labs/quill/pull/76) ## Which tool fits your workflow? Choose pi-subagentura for Pi agent coordination, CSS Variables for editor tooling, or ScreenSilo for local Chrome and Firefox recording. These three maintained products serve different jobs; the linked contribution case studies document work in other projects. ### Need coordinated agents? Start with pi-subagentura and install the Pi extension from npm. ### Need CSS answers? Choose the CSS Variables client for VS Code, Zed, or another LSP editor. ### Need a private capture? Install ScreenSilo for Chrome or Firefox, or build the Chromium extension from source. **Sources and review dates** ## Sources and review. Reviewed by [lmn451](https://github.com/lmn451) on 21 October 2026. The directory contains three maintained products. AXI, Chrome DevTools MCP, and Quill are independently maintained projects; their contribution status is documented in the linked case studies. - [pi-subagentura repository and releases](https://github.com/lmn451/pi-subagentura) - [CSS Variables Rust language server](https://github.com/lmn451/css-lsp-rust) - [ScreenSilo source and installation](https://github.com/lmn451/screencast) --- Source: https://subagentura.tech/screencast/ # Private screen recording. Record it. Keep it. Capture a tab, window, or entire screen without an account or an upload. Preview locally, download the WebM, and stay in control of every frame. [Add to Chrome](https://chromewebstore.google.com/detail/screensilo/higbocdfimfmcjckomeggbbigcglpdje) [Add to Firefox](https://addons.mozilla.org/en-US/firefox/addon/screensilo/) [View the source](https://github.com/lmn451/screencast) No sign-in No uploads No extension tracking Manifest V3 ## From screen picker to saved file. Native browser APIs, a focused interface, and no service standing between you and the recording. ### Local by default Recordings stay in your browser. ScreenSilo has no upload service, account, or analytics pipeline. ### Pick the right surface Capture a tab, window, or screen, with optional microphone and available system or tab audio. ### Stop without hunting End a recording from the toolbar popup or the small on-page overlay, then jump straight to preview. ### Keep the file Preview locally, download a WebM, or delete it. The recording remains under your control. ## Your recording never needs to leave the browser. ScreenSilo processes and stores recordings locally. There is no backend account, cloud upload, telemetry endpoint, or broad`` host permission. [Read the full privacy policy](https://subagentura.tech/screencast/privacy/) ### Local processing Native browser capture and MediaRecorder APIs capture and encode video on-device. ### Local storage Recording chunks and previews are persisted in browser-managed IndexedDB. ### Narrow permissions Manifest V3 permissions support capture, the stop overlay, local state, and recovery. ### Inspectable implementation Inspect the recording lifecycle, message validation, storage, and tests on GitHub. ## Capture, preview, done. Four short steps, then a portable file under your control. 01 ### Open Click ScreenSilo in Chrome, Edge, or Firefox. 02 ### Choose Select a tab, window, or screen and configure audio. 03 ### Record Capture your walkthrough and stop from the page or popup. 04 ### Save Preview the local recording, then download the WebM. ## Install ScreenSilo or inspect the source. Install v0.2.3 from the Chrome Web Store or Firefox Add-ons. For a source build, clone the repository and load the unpacked Chromium extension. GitHub release archives and store publication are separate distribution paths. [Chrome Web Store](https://chromewebstore.google.com/detail/screensilo/higbocdfimfmcjckomeggbbigcglpdje) [Firefox Add-ons](https://addons.mozilla.org/en-US/firefox/addon/screensilo/) [Browse the repository](https://github.com/lmn451/screencast) Manifest V3 MediaRecorder IndexedDB TypeScript esbuild ### Load it unpacked Build locally, then add the repository folder to Chromium. ``` git clone https://github.com/lmn451/screencast.git cd screencast && pnpm install && pnpm run build ``` - Open `chrome://extensions` or your browser equivalent. - Enable Developer mode. - Choose Load unpacked and select the repository folder. ## ScreenSilo recording questions. Practical answers before you install or use the code. ### What can ScreenSilo record? Select a tab, window, or screen in your browser's sharing prompt. Microphone audio and system or tab audio are optional; availability depends on the browser, operating system, and selected surface. In v0.2.3, microphone and system audio are mixed into one recorded track. ### Which browsers and versions are supported? The v0.2.3 Chromium package requires Chrome or Edge 116 or later. The Firefox Add-ons listing declares Firefox 109.0a1 or later. The repository also documents unpacked installation in Brave, Opera, and Vivaldi; it does not publish a separate operating-system compatibility matrix. ### Can I record my webcam or edit the video in ScreenSilo? Current documentation covers screen capture and optional audio, without webcam capture, in-app trimming, or format conversion. Preview the recording locally and download a WebM file, then use a separate editor if you need to edit or convert it. ### Are recordings uploaded or encrypted? The extension has no upload service and does not send recordings to its developer. Recordings remain in browser-managed IndexedDB until you delete them or browser data is cleared, including according to the browser's extension-removal behavior. ScreenSilo does not encrypt them at rest. Downloading does not delete the browser copy, and downloaded copies remain outside the extension. ### Does ScreenSilo track me? The extension has no analytics pipeline and does not send capture data to its developer. The product website is separate and loads site analytics; the privacy-policy page disables site analytics. Sharing a downloaded recording through another app is governed by that app's behavior. ## Sources and review. Reviewed by [lmn451](https://github.com/lmn451) on 21 October 2026. Version 0.2.3 was released on 11 September 2026. Store compatibility metadata and available capture/audio sources are browser-specific. This product page loads website analytics; the extension does not, and the privacy-policy page disables them. - [v0.2.3 release and Chromium minimum version](https://github.com/lmn451/screencast/releases/tag/v0.2.3) - [Chrome Web Store listing](https://chromewebstore.google.com/detail/screensilo/higbocdfimfmcjckomeggbbigcglpdje) - [Firefox Add-ons version history](https://addons.mozilla.org/en-US/firefox/addon/screensilo/versions/) - [Mozilla compatibility metadata](https://addons.mozilla.org/api/v5/addons/addon/screensilo/) - [Source at the reviewed revision](https://github.com/lmn451/screencast/tree/5f806c385b753cbc757da90a7a19377b3b380a95) ## Behind the build - [How ScreenSilo keeps screen recordings local](https://subagentura.tech/blog/keeping-recordings-local/) --- Source: https://subagentura.tech/screencast/privacy/ # ScreenSilo Privacy Policy ScreenSilo records a surface you select and keeps the resulting video, optional audio, metadata, and diagnostics on your device. **Effective date** October 21, 2026 **First published** August 14, 2026 **Applies to** ScreenSilo browser extension **Support** [hello@subagentura.tech](mailto:hello@subagentura.tech) POLICY CONTENTS This policy page does not load site analytics. ## Scope This policy describes the ScreenSilo browser extension. ScreenSilo performs its recording work locally in your browser and does not require an account or upload service. The website hosting this policy is separate from the extension. ScreenSilo does not load this website or any website analytics code. ## Information ScreenSilo processes ScreenSilo processes only the information needed to provide its recording features: - The visual content of the tab, window, or screen you explicitly select in the browser's screen-sharing prompt. - Microphone audio and system or tab audio when you explicitly enable those options and grant permission. - Recording metadata such as an internal identifier, creation time, duration, file type, file size, and completion status. - Minimal session-recovery state including recording mode, audio choices, timestamps, and internal identifiers. - Local diagnostic entries such as error messages, stack traces, internal identifiers, and recording state. Diagnostics do not contain recorded video or audio. ## Local storage and retention Recordings and recording metadata are stored in browser-managed IndexedDB on your device. Completed recordings remain there until you delete them from the preview or recordings page. Downloading a recording does not automatically delete the browser copy. ScreenSilo does not encrypt recordings at rest; protect access to your device and browser profile. Downloaded or exported copies remain outside the extension and must be deleted separately. Minimal recovery state is stored locally so ScreenSilo can recover from a suspended service worker or interrupted recording. It is removed or replaced as the recording lifecycle completes. ScreenSilo keeps a local rolling buffer of up to 500 diagnostic entries. You can view, export, or clear them from Diagnostics. Export occurs only when you choose it and creates a local file. ## Data collection, transmission, and sharing ScreenSilo does not transmit recordings, audio, metadata, diagnostics, browsing history, or personal information to the developer or external servers. It has no analytics, advertising, account, or cloud-upload service and does not sell or share user information with third parties. Downloading a recording or exporting diagnostics creates a local file; it does not upload the file. If you share that file through another app or service, that software handles the transfer. ## Browser permissions **`activeTab`** Temporarily accesses the active tab after your action so recording controls can appear. **`scripting`** Injects and removes the small in-page Stop overlay. **`offscreen`** In the Chrome/Edge package, keeps local capture and encoding active after the popup closes. Firefox uses its own extension implementation without this permission. **`storage`** Stores minimal recording-session recovery state locally. **`alarms`** Schedules local checkpoints and service-worker reconciliation. ScreenSilo does not request broad host access such as ``. ## User controls You control when capture starts, which surface is shared, whether audio is included, and when capture stops. You can delete recordings individually and clear local diagnostics. Removing ScreenSilo also removes extension-managed local data according to your browser's uninstallation behavior. ## Chrome Web Store Limited Use ScreenSilo's use of information received from Chrome APIs adheres to the Chrome Web Store User Data Policy, including the Limited Use requirements. ## Changes to this policy This policy will be updated if ScreenSilo's features or data practices change. The effective date identifies the latest revision. ## Contact For privacy or support questions, email[hello@subagentura.tech](mailto:hello@subagentura.tech) . ## Sources and review. Reviewed by [lmn451](https://github.com/lmn451) on 21 October 2026. The 21 October revision clarifies unencrypted local storage, downloaded copies, and browser-specific permission behavior. ScreenSilo's extension data practices are separate from this website. This policy page does not load site analytics. - [Reviewed extension source and browser manifests](https://github.com/lmn451/screencast/tree/5f806c385b753cbc757da90a7a19377b3b380a95) - [Local chunk storage implementation (unencrypted IndexedDB blobs)](https://github.com/lmn451/screencast/blob/5f806c385b753cbc757da90a7a19377b3b380a95/src/lib/chunkStorage.js) - [v0.2.3 recording and recovery release notes](https://github.com/lmn451/screencast/releases/tag/v0.2.3)