TL;DR
ThinkRail (JetBrains/thinkrail) is an open-source agentic IDE from a JetBrains incubator team, built around the pi coding agent. It is not a new agent. pi still owns the models, the skills, context compaction, cost tracking and session state. ThinkRail adds the window around it: git-worktree workspaces, a Monaco editor, terminals, a diff and review flow, a graph of SPEC.md files the agent maintains, and a pull-request flow in the topbar from “Publish” to “Merge”.
Facts as of November 1, 2026:
- 6,867 GitHub stars, 380 forks. The repo was created on July 8, 2026, and picked up 5,738 stars in the past week, mostly after its Hacker News launch.
- 217 open issues (issues only, not pull requests; there are also 108 open PRs).
- License: Apache-2.0.
- Latest stable release: v0.3.0, published October 29, 2026. Nightlies ship daily;
v0.4.0-nightly.2went out this morning. - The main branch pins pi 1.4.0 (
@earendil-works/pi-coding-agent), run in-process.
Our verdict: ThinkRail is the most considered graphical front end for pi so far, and the worktree-per-task model plus the topbar PR flow are the parts worth trying. The install worked cleanly in our test container. The catches: it is version 0.x from a team inside a company that also sells a competing product (JetBrains Air), error reports are sent unconditionally, agents run on your machine without a sandbox, and it only makes sense if you are happy with pi as your engine.
Quick Reference
| Field | Value |
|---|---|
| What it is | Desktop / browser IDE wrapped around the pi coding agent |
| Engine | pi (1.4.0 pinned on main), run in-process (Bun host) |
| Clients | Native desktop app (macOS, Windows, Linux) or thinkrail CLI that serves the UI to a browser |
| Default port | 24242, bound to localhost |
| Install | curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash |
| Price | Free; you pay your model provider (or JetBrains AI) |
| Accounts | None of its own; sign in with JetBrains AI or any pi provider |
| Local models | Yes: any OpenAI-compatible server (Ollama, LM Studio, vLLM, llama.cpp, LiteLLM) |
| MCP | Yes, with per-call approval for tools not marked read-only |
| Telemetry | Basic usage events + error reports always on; extra sharing opt-in |
| License | Apache-2.0 |
| Latest stable | v0.3.0 (October 29, 2026) |
What ThinkRail Actually Is
The README calls ThinkRail “a thin host that runs pi in-process and bridges it to a rich web UI.” It has three parts: an engine host (packages/server, a Bun.serve HTTP and WebSocket server running one pi session per chat), a typed protocol (packages/contracts), and a React 19 UI (apps/web). The desktop app (Electrobun) and the thinkrail CLI start the same host; the CLI just opens your browser to it, so you can run it on one machine and use it from another.
The team is explicit that it does not reinvent the agent. An October 1 post says: “nothing about how the agent thinks, what it is allowed to do, or how it manages context is ThinkRail’s to reinvent.” It reads your existing ~/.pi/agent configuration, skills and models.json.
That makes it the opposite of T3 Code, which drives many agents from one screen. ThinkRail drives exactly one agent and goes deeper with it.
Why It Is Trending Now
ThinkRail was announced in August but took off in late October. A Hacker News thread on October 24 (59 points, 84 comments) was followed the next day by “JetBrains Thinkrail”, which reached 242 points and 174 comments. The v0.3.0 release on October 29 added a first-run wizard, the full PR flow and localization. pi itself now has more than 119,000 GitHub stars, and many of its users want something more visual than a terminal (see our pi coding agent review).
Key Features
Isolated workspaces on git worktrees
You open a repository as a project and create workspaces from it. Each is a git worktree with its own branch and folder, so several agents work in parallel without touching your checkout. Merge the branch that worked, delete the rest. Finished or idle workspaces move to a per-project shelf when their PR merges or closes, or after a quiet week.
A real editor around the chat
A splittable workbench holds Monaco editor tabs, a Files tree with live git change marks (with an All | Changed switch since v0.3.0), terminals and documents, all scoped to the active workspace. You can leave anchored review comments on files and diffs and send them to a chat as structured context.
Chats, plans and subagents
Each workspace runs several pi sessions at once, each with its own model and a live token and cost readout. You can steer a running turn, queue a follow-up, delegate to subagents, and share an editable plan with the agent; each completed step can be committed on its own. v0.2.0 added a Review turn button so you review what one turn changed, not the whole chat log.
v0.3.0 fixed two real problems: the cost counter now includes subagent spend (it used to count only the parent session), and background results are no longer delivered to the agent twice. The team says 174 of 195 background completions in their own logs had been duplicates.
Specs as ground truth
ThinkRail’s central idea: a connected graph of SPEC.md files sits beside the code, and the agent reads, searches and updates it through dedicated spec_* tools. ThinkRail’s own repo is built this way. The team’s spec-driven development post explains the method: specs state intent and are never generated from code.
PR flow in the topbar
The topbar shows Remote and Pull request for the open workspace with the next step: Publish, Push, Sync, Open PR, Fix with agent (when checks fail), Ready for review, Merge PR. PR descriptions can come from the plan, the commits, your PR template or an agent draft. It works through your own gh CLI. Local merges and GitLab review actions are not supported yet.
Extra tools, MCP and models
ThinkRail adds web research, a multiple-choice “ask user” tool, and a visualize tool that renders diagrams and before/after HTML mockups in the chat. The last two are also published as pi packages for plain pi:
pi install npm:@thinkrail/pi-ask-user-question
pi install npm:@thinkrail/pi-visualizeMCP servers come from your pi mcp.json. ThinkRail asks before any call a server does not mark read-only, and servers defined by a repository stay off until you approve them. For models, sign in with JetBrains AI or any pi provider, or add an OpenAI-compatible server (Ollama, LM Studio, vLLM, sglang, llama.cpp, LiteLLM) under Settings → Providers → Custom servers.
Getting Started
The installer downloads the binary for your platform, verifies its SHA-256 checksum and puts thinkrail on your PATH:
curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash
thinkrail ~/code/my-repo # open a repo as a project
thinkrail --no-open --port 24242 ~/code/my-repo # headless, e.g. on a remote boxYou need git and a model provider. --channel stable|nightly and --version pin a build; thinkrail update and thinkrail uninstall do what they say. Desktop builds for macOS, Windows and Linux are on the releases page. Linux desktop builds need glibc 2.38+ with GTK 3 and WebKitGTK 4.1 (Ubuntu 24.04 or newer) and are unsigned; the macOS CLI is signed but not notarized. Building from source needs Bun 1.4.4 and Node.js 22.19+.
Hands-on test (November 1, 2026)
We ran ThinkRail’s CLI in a fresh node:22-bookworm container on a GitHub-hosted runner (x86_64, 2 CPUs, 8 GB RAM, no GPU) against commit 45778444aabd. We installed it with the project’s own install script, checked the version and help, started the host headless against a small git repo, and checked that it served its health endpoint and the web app. The verdict is passed: 5 of 5 steps passed in 25.1 seconds in total.
| Step | Result | Time |
|---|---|---|
Install via install.sh --no-modify-path | Resolved stable v0.3.0, checksum “ok”, installed to /root/.local/bin/thinkrail | 4.2 s |
thinkrail --version | 0.3.0 | 0.5 s |
thinkrail --help | Printed usage with --port (default 24242), --host (default localhost), --no-open, --no-analytics | 0.2 s |
Start host with --no-open --no-analytics on a one-commit repo, then curl /health and / | /health returned ok with HTTP 200; / returned the ThinkRail HTML page; the log showed “listening on port 24242” | 20.1 s (includes our 20-second wait) |
List ~/.thinkrail | Created locales/, logs/, themes/, projects.json, session-lifecycle.json, session-receipts.json | 0.1 s |
What worked: the installer is quick and does what it says, including checksum verification, and the single binary runs on a stock Debian image with nothing else installed. The host started with no browser and no account, which confirms the README’s claim that you can run it on a headless or remote box and open the UI elsewhere.
What this test does not tell you: we did not connect a model provider, open the UI in a browser, or let pi run a task, so we have not checked agent quality, workspace creation, the spec tools, the PR flow or the cost readout. Those all depend on pi and on the model you pick. The 20.1 seconds for the host step is mostly our fixed sleep 20; the log shows the host listening well before that, but we did not time it separately.
Things to Check Before You Adopt It
Telemetry is partly unconditional. The README says basic usage events (launches, chat creation, message sends, provider connections) and error reports are sent to PostHog, tied to a random installation ID, and that they never include prompts, code, file paths or account identity. --no-analytics turns off only the opt-in “additional usage data”, not the basic events or error reports.
No sandbox. pi has no built-in permission system for its shell tool, and ThinkRail adds no container. Worktrees protect your checkout from edits, not your machine from commands. A highly upvoted HN comment: “Running agents outside containers seems crazy to me.” Run it in a VM or dev container if that matters.
Keep the host on localhost. It binds to localhost by default. In the server code we read (packages/server/src/host/server.ts), the /ws WebSocket upgrade takes a client key, and we did not see an access-token check. Do not use --host 0.0.0.0 on a shared network; use an SSH tunnel or Tailscale.
It is 0.x and moves fast. v0.2.0 and v0.3.0 shipped eleven days apart, nightlies go out daily, and there are 217 open issues.
JetBrains’ strategy is unclear. JetBrains also ships JetBrains Air and the AI Assistant in its IDEs. One HN commenter complained the company now has “both Air and ThinkRail in a feature-incomplete state”. ThinkRail is an incubator project, which is no promise it will last.
Who Should Use It
- pi users who want a GUI. Config, skills and models carry over, and you can drop back to the terminal anytime.
- People running several agents in parallel who are tired of managing worktrees by hand.
- Teams trying spec-driven development.
- Anyone who wants local models in an agent IDE.
Skip it if you are committed to Claude Code or Codex as your agent (ThinkRail only runs pi), need a security-approved tool, or want AI deeper inside an existing IntelliJ setup.
Alternatives
| Tool | How it differs |
|---|---|
| pi (terminal) | The same engine with no GUI; MIT; maximum control |
| T3 Code | One GUI for many agents (Claude Code, Codex, Cursor, pi); strong remote access; MIT |
| Juggler | Hands-on GUI for coding agents from the creator of JUCE |
| JetBrains Air | JetBrains’ own agentic environment; works with any ACP-compatible agent |
| Cursor / Claude Code desktop | Polished commercial products tied to one vendor’s agent |
Community Reactions
The Hacker News response was split. pi fans were pleased (“I cannot express how happy I am that it uses a Pi core”). Long-time JetBrains users doubted the company’s direction, and some called the README obviously AI-written. On specs, one commenter argued no harness can guarantee an agent “actually reads” one, since it may drop it from context. A DEV Community post summed up the positive case: JetBrains “open-sourced an agentic IDE where agents never touch your checkout.”
FAQ
Is ThinkRail free?
Yes. It is Apache-2.0 open source with no accounts or paid tier. You pay your model provider, use JetBrains AI, or run a local model.
Does ThinkRail work with Claude Code or Codex?
Not as agents; it only runs pi. pi supports Anthropic and OpenAI models, so you can still use Claude or GPT models through pi’s own sign-in.
Can I use ThinkRail with Ollama or another local model?
Yes. Any OpenAI-compatible server works, and it is saved to pi’s models.json, so it also appears in the pi CLI.
How is ThinkRail different from JetBrains Air?
ThinkRail is an open-source incubator project built only around pi, with spec files at its core. JetBrains Air is a separate JetBrains product that works with the agents you already use and any ACP-compatible agent.
Does ThinkRail send my code anywhere?
Its telemetry goes to PostHog and, per the README, excludes prompts, code and files. Your code does go to whichever model provider you connect.
Can I run it on a server and use it from a browser?
Yes. thinkrail --no-open starts the headless host, which our test confirmed. Reach it through an SSH tunnel or private network.
Bottom Line
ThinkRail is what a GUI for pi should look like: it adds structure (worktrees, specs, per-turn review, a PR flow) without changing how the agent works, and our install test was clean. Whether to switch depends on whether pi is your agent and whether you accept 0.x software, unconditional error reporting and no sandbox. If yes, it is worth an afternoon. Run it in a VM if the agent runs commands unattended.
Sources
- JetBrains/thinkrail on GitHub: README, stars, license, issue counts
- ThinkRail v0.3.0 release notes
- ThinkRail 0.3.0: the whole loop in one window
- ThinkRail Spec-Driven Development
- An agentic IDE that follows Pi’s philosophy
- ThinkRail architecture.md
- earendil-works/pi on GitHub
- Hacker News: JetBrains Thinkrail (242 points)
- Hacker News: ThinkRail from JetBrains
- DEV Community: JetBrains open-sourced an agentic IDE where agents never touch your checkout
- JetBrains Air announcement