ThinkRail: An Adaptive Agentic IDE Built Around pi and Git Worktrees
A pi-based IDE for parallel coding that isolates work with worktrees and preserves context in SPEC.md.
GitHub JetBrains/thinkrail Updated 2026-10-26 Branch main Stars 1.7K Forks 102
TypeScript React 19 Bun pi Git worktree MCP Monaco Desktop and browser

🧭 Decision Guide

Try it if you

  • You need multiple agents to modify the same Git repository in parallel without touching the current checkout.
    The README's 「What you get」 → 「Isolated workspaces」 section says each workspace uses a git worktree with its own branch and working directory.
  • You use pi and want several model sessions running concurrently in one workspace.
    「Chats that stream like the engine thinks」 says each workspace supports several concurrent pi sessions with individual models, token counts, and cost readouts.
  • Your team maintains design intent with SPEC.md and wants the agent to read and update it across sessions.
    「Specs as ground truth」 and 「Under the hood」 describe the SPEC.md graph and spec_* tools used to maintain project specifications.
  • You need Monaco editing, GitHub PRs, CI checks, and MCP tools in one workbench.
    「A real IDE around the agent」, 「MCP servers」, and 「Isolated workspaces」 list Monaco, PR/CI operations, and MCP integration respectively.

Skip it if you

  • You use macOS Intel and cannot build the CLI from source.
    The README's 「Platform notes」 explicitly says the macOS Intel CLI is not prebuilt and must be built from source.
  • Your Linux environment requires every downloaded executable to be signed.
    The README's 「Platform notes」 explicitly says Linux x64 / ARM64 artifacts are unsigned.
  • You cannot accept launch, chat-creation, and provider-connection analytics tied to an installation ID.
    「Analytics & privacy」 says these basic usage events are tied to a random installation ID; additional data can be disabled in Settings → Privacy.
  • Your environment cannot provide Bun 1.4.4, Node.js ≥22.19, or an authenticated pi provider.
    「Developing ThinkRail」 lists Bun 1.4.4, Node.js ≥22.19, and an authenticated pi provider as prerequisites.

Requirements

  • Development requires Bun 1.4.4 (the pinned package manager and runtime).
  • Development requires Node.js ≥ 22.19 (required by the in-process pi engine).
  • Agent work requires an authenticated pi provider.
  • Both desktop and CLI releases provide SHA256SUMS; Linux x64 / ARM64 artifacts are unsigned.
  • When launching the CLI, thinkrail --no-analytics or THINKRAIL_NO_ANALYTICS=1 disables additional sharing for that run.

First step (verbatim from README)

git clone https://github.com/JetBrains/thinkrail.git

Watch out

  • The macOS CLI is signed but not yet notarized; older DMGs or locally built packages may be blocked by Gatekeeper.
    The README's 「Platform notes」 says the macOS CLI is signed but not yet notarized, while older DMGs and local packages may be unsigned.
  • Repository-defined MCP servers are off by default, and non-read-only calls require approval in chat.
    「MCP servers」 says repository-defined servers remain off until approved and asks before calls.
  • ThinkRail provides no account of its own; provider authentication relies on JetBrains AI or pi's own auth.
    「Your providers, your credentials」 states that ThinkRail has no accounts of its own.
  • When additional usage data is enabled, a packaged build may open the ThinkRail blog to link the visit.
    「Analytics & privacy」 says that with Share additional usage data enabled, a packaged build may open the ThinkRail blog, with the link expiring after 30 days.

Not stated in the README

  • The README does not specify supported model names or compatibility coverage across providers.
  • The README does not provide runtime resource requirements for the desktop app or CLI, such as CPU, memory, or disk space.
  • The README does not explain the composition of the 1,744 stars, 102 forks, and 201 issues, or identify unresolved issues.
  • The README does not describe functional or compatibility differences between Nightly 0.3.0-nightly.6 and a stable release.
  • The README does not give the exact macOS Intel source-build steps or artifact verification process.
  • The README does not provide the complete analytics event field list or quantify feature differences after analytics are disabled.

💡 Deep Analysis

6
Yes, because it binds parallel agent tasks to isolated Git worktrees and connects commits, CI, review, and Pull Request delivery. We need several concurrent pi sessions to implement features on separate GitHub branches, then create and merge Pull Requests after CI passes. Is ThinkRail suitable for replacing a workflow where agents edit the main checkout directly?
For: A software team running multiple GitHub feature branches that requires every AI task to be independently committed and reviewed

Yes, because ThinkRail’s workspace isolation and GitHub delivery features directly match this constraint.

  • Each workspace can be a separate git worktree with its own branch and working directory, so agents do not modify the current checkout. This is designed for parallel feature work.
  • A workspace can run several concurrent pi sessions, each with its own model and live token and cost readouts.
  • Plan steps can be committed and reviewed independently. Once a GitHub PR is open, ThinkRail can show CI and review status, delegate failing checks or branch divergence to the agent, merge the PR, and delete the remote branch.
  • The workflow still depends on Git, branch permissions, and a correctly configured gh; it is not suitable for repositories that cannot use those mechanisms.
  • What you get: "each with its own branch and working directory. Agents work in parallel without touching your checkout"
  • What you get: "Several concurrent `pi` sessions per workspace"
  • What you get: "each completed step can be committed and reviewed on its own"
  • Project insight: GitHub Pull Request, CI, and review status are integrated
bun run dev                          # host + web client together; Ctrl+C stops both
Not stated in the README:The README does not explain how conflicts are resolved when multiple agents modify the same files or module concurrently.;It does not specify whether enterprise GitHub organization policies may block automated merging or remote-branch deletion.
No, not as a mature cross-platform desktop IDE, because the project has explicit distribution and signing limitations, especially on macOS Intel and Linux. We need ThinkRail on macOS Intel and Linux, while enterprise endpoint controls block unsigned or unnotarized applications. Can we roll it out as a mature cross-platform desktop IDE?
For: A developer deploying a lightweight IDE across macOS Intel, Linux, and browser mode under enterprise signing, notarization, and endpoint-security policies

No, not as a mature cross-platform desktop IDE, because the README identifies enterprise deployment risks in platform support and signing.

  • The project provides both a native desktop app and the thinkrail CLI browser mode, using the same engine. The browser mode can therefore be an alternative when desktop packaging is blocked.
  • The project insight states that macOS Intel has no prebuilt desktop release, Linux artifacts are unsigned, and the macOS CLI is not notarized; some systems may trigger security blocks.
  • The latest release is v0.3.0-nightly.6, and the project data shows only five releases, indicating a rapidly changing project rather than an established enterprise desktop platform.
  • The README says both installers and the CLI are published with SHA256SUMS. Checksums verify file integrity, but they do not replace code signing, notarization, or enterprise approval.
  • What you get: "A native desktop app, or the `thinkrail` CLI that opens the same app in your browser"
  • Project insight user_experience.common_pitfalls: no prebuilt macOS Intel desktop app, unsigned Linux artifacts, and an unnotarized macOS CLI
  • Project data: latest_release is `v0.3.0-nightly.6` and release_count is 5
  • Install: "Both are published with `SHA256SUMS`"
bun run build:binary
Not stated in the README:The README does not provide an official process for enterprise signing, notarization, or internal repackaging.;It does not say whether browser mode satisfies enterprise network isolation, proxy, and local-file access policies.;It does not provide a formal support matrix for macOS Intel or Linux.
Yes, provided the team continuously maintains SPEC.md; ThinkRail exposes an agent-readable, searchable, and maintainable spec graph, but does not automatically guarantee that the specs remain correct. We already use SPEC.md to record architecture boundaries and business constraints, and we want multiple pi sessions to read and maintain them. Can ThinkRail serve as a durable project-knowledge layer rather than merely a one-off code-generation interface?
For: A technical lead of a specification-driven team that must preserve architecture boundaries, business rules, and acceptance criteria across sessions

Yes, provided the team treats SPEC.md as a continuously maintained engineering asset.

  • The README describes a connected graph of SPEC.md files beside the code. Agents can read, search, and maintain it through dedicated spec_* tools, allowing project intent to survive across chat sessions.
  • The read-only Specs tool renders the graph as a tree in the workbench, making module relationships visible to the technical lead instead of hiding them inside model context.
  • The project insight explicitly connects specs, plans, independent commits, diff review, CI, and PR delivery, which fits repositories that need durable architectural decisions.
  • The limitation is that the README does not describe spec migration, stale-spec detection, or conflict validation. If the documents are not synchronized with code, the agent may follow obsolete intent.
  • What you get: "Specs as ground truth"
  • What you get: "A connected graph of `SPEC.md` files lives beside the code"
  • What you get: "the agent reads, searches, and maintains it through dedicated `spec_*` tools"
  • Project insight: specs live beside code, are maintained by module, and should be updated when boundaries change
bun run dev                          # host + web client together; Ctrl+C stops both
Not stated in the README:The README does not say whether existing non-SPEC.md documentation can be imported automatically into the spec graph.;It does not describe locking, merging, or version-conflict handling when multiple agents edit the same SPEC.md concurrently.
Yes, because ThinkRail is an IDE and host around pi rather than a replacement model layer; actual model availability still depends on an authenticated pi provider. I already depend on pi’s model providers and authentication. I want concurrent sessions in one worktree, using different models for research, implementation, and review. Does ThinkRail replace pi, or does it preserve pi’s capabilities?
For: An advanced developer already using the pi coding agent who needs different models for different tasks while monitoring tokens and cost in one workspace

Yes, because ThinkRail keeps pi as the source of agent, model, and session capabilities.

  • The README says it builds a rich interface around the pi coding agent. The project insight further assigns models, skills, context compaction, cost, and session state to pi, while ThinkRail handles workspaces, the editor, and communication.
  • One workspace supports multiple concurrent pi sessions, each with its own model and live token and cost readouts. That matches separate research, implementation, and review activities.
  • Authentication remains provider-based: users can sign in with JetBrains AI or connect another provider through pi’s own auth. ThinkRail has no accounts of its own.
  • Development requires Bun 1.4.4, Node.js 22.19 or newer, and an authenticated pi provider. The README does not promise identical capabilities or pricing across all pi providers.
  • What you get: "We built a rich interface around the `pi` coding agent"
  • What you get: "Several concurrent `pi` sessions per workspace, each with its own model and live token and cost readout"
  • What you get: "Sign in with JetBrains AI or connect any provider through `pi`'s own auth"
  • Developing ThinkRail: "Bun 1.4.4", "Node.js ≥ 22.19", and "an authenticated `pi` provider"
bun install
Not stated in the README:The README does not list a verified set of specific models or provider limits for concurrent sessions, subagents, or context size.;It does not clarify whether token and cost readouts represent actual charges for every provider or only pi-level estimates.
It depends, because the README explicitly excludes prompts, code, files, and credentials, but basic usage events and error reports are still sent, and the statement does not fully cover model or MCP data flows. My repository contains sensitive code. Our organization requires a clear review of ThinkRail’s data collection and the ability to disable additional sharing from the command line. Are the README’s privacy controls sufficient for this constraint?
For: A developer working on sensitive repositories who requires prompts and code not to be uploaded and needs to disable additional analytics from the CLI

It depends, because ThinkRail’s product analytics scope is clearly described, but compliance for sensitive code also depends on the organization’s requirements for models and extensions.

  • The README says basic events cover launches, chat creation, message sends, and provider connections, tied to a random installation ID. They do not include prompts, code, files, credentials, or account identity.
  • Error reports contain only the error type, code, and where it occurred in ThinkRail’s own code. They exclude error messages, file paths, names, URLs, and project content.
  • Additional product-usage data can be disabled in Settings → Privacy. For a CLI run, use thinkrail --no-analytics or set THINKRAIL_NO_ANALYTICS=1.
  • These statements do not mean that model providers, MCP servers, or agent extensions cannot receive project content. The project insight says organizations must define their own rules for secrets, code egress, MCP permissions, and third-party models.
  • Analytics & privacy: "Usage analytics never include prompts, code, files, credentials, or account identity"
  • Analytics & privacy: "Error reports are also always sent"
  • Analytics & privacy: "thinkrail --no-analytics" or "THINKRAIL_NO_ANALYTICS=1"
  • Project insight user_experience.common_pitfalls: organizations must define rules for secrets, code egress, MCP permissions, and third-party models
thinkrail --no-analytics
Not stated in the README:The README does not say where prompts and code sent through JetBrains AI or another pi provider are processed or how long they are retained.;It does not describe data handling, log retention, or compliance certifications for MCP servers and Agent Skills.;It does not say whether basic error reporting can be disabled completely.
It depends, because ThinkRail provides call confirmation, default-off repository servers, and OAuth sign-in controls, but the README does not claim to perform organizational permission audits. My project needs MCP and OAuth services, but organizational policy requires confirmation for non-read-only calls and keeps repository-declared servers disabled by default. Does ThinkRail provide sufficiently explicit permission controls?
For: An advanced developer who needs MCP, repository-declared tools, and OAuth services while requiring confirmation for writes and restricted third-party access

It depends, because ThinkRail exposes clear MCP control points but cannot replace an organization’s permission review.

  • ThinkRail asks in chat before invoking an MCP tool that is not marked read-only. Trusted tools in a project can be configured to always allow, separating lower-risk reads from writes.
  • MCP servers declared by a repository are disabled by default and require approval. OAuth servers can be authenticated from Settings, and the current chat shows its servers alongside background commands and subagents.
  • ThinkRail extensions can be switched off from Settings → Extensions. The project insight also identifies extension toggles and call confirmation as explicit permission boundaries.
  • However, the MCP server’s code, network access, credential scope, and data residency still require separate review. The README does not promise enterprise allowlists, audit logs, or sandboxing.
  • What you get: "asks in the chat before calls the server does not mark read-only"
  • What you get: "keeps servers a repository defines off until you approve them"
  • What you get: "signs you in to OAuth servers from Settings"
  • What you get: "Settings → Extensions lists the ThinkRail extensions the agent gets and lets you switch each one off"
Not stated in the README:The README does not say whether MCP calls produce complete audit logs that an organization can export.;It does not say whether MCP servers run in an isolated sandbox or whether credentials can be scoped to one worktree or session.;It does not explain whether repository-level MCP configuration can be centrally prohibited by organizational policy.

✨ Highlights

  • Isolates parallel agent work with Git worktrees
  • Combines Monaco, terminals, and live Git status
  • Multiple pi sessions expose live token and cost data
  • SPEC.md graphs preserve project knowledge across sessions
  • macOS Intel has no prebuilt CLI

🔧 Engineering

  • Creates isolated branches and working directories with git worktree for parallel agents.
  • A splittable IDE workbench is built with React 19, Zustand, and Tailwind v4.
  • Each workspace can run multiple pi sessions with token and cost readouts.
  • SPEC.md files and spec_* tools maintain a specification graph beside the code.
  • Connects pi's mcp.json, OAuth MCP servers, and GitHub gh workflows.

⚠️ Risks

  • macOS Intel has no prebuilt CLI and requires building from source per Developing ThinkRail.
  • Linux x64/ARM64 artifacts are unsigned and may trigger system security blocks.
  • Development requires Bun 1.4.4, Node.js ≥22.19, and an authenticated pi provider.
  • By default, launch, chat, and provider-connection events are tied to an installation ID.
  • Repository-defined MCP servers are off by default and require approval for tool calls.

👥 For who?

  • Agent development teams that need parallel Git branches and PR handling.
  • Engineers working on TypeScript, React 19, or Bun projects.
  • Teams that want to encode project knowledge with SPEC.md and Skills.
  • pi users who need either a desktop app or the thinkrail CLI browser interface.