JetBrains open-sourced ThinkRail, a free IDE wrapping the Pi coding agent in git-worktree workspaces. Here's how it works and how it stacks up to Claude Code.
Vamsi Tallapudi
Manager, Architect Technology at Cognizant
JetBrains ThinkRail is a free, open-source IDE the company released in August 2026 as a graphical wrapper around Pi, a minimalist open-source coding agent. It gives Pi a Monaco-based editor, a file tree, terminals, and (the actual headline feature) git worktree "workspaces" so you can run several agent sessions on separate branches at once without any of them touching your main checkout.
That's the whole pitch in one sentence. The rest of this post is about whether that pitch holds up, what Pi even is if you haven't run into it, and how the combination stacks up against Claude Code, which is the tool most working devs are actually comparing it to.
Pi is a small, extensible AI coding agent created by Austrian developer Mario Zechner, known online as badlogic, and better known before this for creating the libGDX game framework. Pi first shipped in August 2025 out of his pi-mono repo, then got handed to a company called Earendil Inc in May 2026, co-founded by Armin Ronacher (yes, the Flask guy). The project now lives under the earendil-works org and ships as the npm package @earendil-works/pi-coding-agent.
The whole design philosophy is "small core, everything else is a plugin." Pi's system prompt runs under 1,000 tokens with four built-in tools: read, write, edit, and bash. Claude Code's system prompt, by comparison, runs in the 14,000-to-24,000-token range depending on which tools are loaded, with 10+ built-in tools of its own. Zechner's stated argument is that frontier models are already trained to be coding agents, so you don't need to spend thousands of tokens re-explaining the concept to them every turn. Pi connects to more than fifteen model providers (Anthropic, OpenAI, Google, Bedrock, Mistral, Groq, and others) and lets you swap providers mid-session. Anything beyond the basics (themes, skills, prompt templates, custom workflows) you write yourself or install as a TypeScript extension. It's MIT-licensed and runs as a terminal UI by default.
That last part is exactly the gap ThinkRail is trying to close. Pi is powerful if you're comfortable in a terminal and want full control. It's also, by design, not very approachable if you're not.
ThinkRail runs Pi in-process inside a Bun-based engine host and bridges it to a React web UI. JetBrains describes the split cleanly in the project's own docs: Pi owns the models, skills, compaction, and cost tracking; ThinkRail owns the workspace, the editor, and the wire between them. It doesn't quietly rewrite your prompts behind the scenes, which is a reasonable thing to brag about given how many "agent IDEs" do exactly that.
Here's what you actually get:
git worktree with its own branch and working directorySPEC.md files that Pi reads and updates as it works, instead of you re-explaining context every sessionIt ships under Apache 2.0, needs Bun 1.4.4 and Node 22.19 or newer, and git has to be on your PATH. JetBrains has pushed four follow-up releases since the August 19 launch: workspaces on September 3, spec-driven development on September 15, a framing update on October 1 pitching it as "an agentic IDE that follows Pi's philosophy," and a 0.2.0 release on October 18 that added a "receipt" system (a per-turn diff summary with Keep/Revert/Ask-agent controls per hunk), so you review what an agent did turn-by-turn instead of scrolling a raw chat log.
This is the part worth understanding even if you never touch ThinkRail. When you open a workspace, ThinkRail cuts a new git worktree off your repo: a separate checkout that shares the same .git history but has its own branch and its own files on disk. Fire up three workspaces and you've got three agents editing three branches in parallel, none of them able to stomp on each other or on your main branch.
You could do this manually with git worktree add and three terminal tabs today. ThinkRail's value is that it turns that into a UI primitive: open a project, click to spin up a workspace, get an editor and a chat session scoped to it automatically. If you've ever had one agent's half-finished refactor clash with another agent's half-finished feature in the same directory, you'll get why this matters.
Mixed, and loudly so. The launch thread pulled real engagement, but a good chunk of the top comments weren't about the worktree idea at all. They were about the README. Commenters called it "overly verbose and flowery AI slop prose," and more than one said some version of "I refuse to take a repo with an AI-generated readme seriously." Which is a little funny, because the worktree-per-agent concept underneath is genuinely sound.
The deeper criticism was strategic, not technical. JetBrains has now shipped Air, abandoned Fleet, kept its existing AI Assistant plugin running, and added ThinkRail on top, and some commenters read that as a company throwing agent-IDE bets at the wall rather than committing to one. "It feels like JetBrains is dying, and they're trying very hard to survive," one comment put it. Harsh, but you can see the pattern they're reacting to. Others said they'd already moved entirely to Claude Code and the terminal and didn't see what problem ThinkRail solved for them.
There was real praise too, mostly from people who wanted exactly this: a GUI for Pi that doesn't bury its minimalism under JetBrains' usual IDE chrome. The Monaco-over-Fleet choice disappointed a few who expected JetBrains' own code-intelligence engine (one comment called it "the lowest common denominator editor UI"), and someone asked, not unreasonably, why a company known for performant native tools built this on TypeScript and Bun instead of anything closer to the metal. Fair question. Bun is fast for a JS runtime, but it's still not what you'd reach for if raw IDE responsiveness were the top priority.
This is the comparison most people actually care about, so here it is straight:
| Pi + ThinkRail | Claude Code | |
|---|---|---|
| Agent core | Under 1,000-token prompt, 4 built-in tools | ~14,000+-token prompt, 10+ built-in tools |
| License/cost | MIT, free agent; model usage billed separately | Commercial, tied to Claude subscription/API usage |
| Interface | Native desktop app or browser CLI, Monaco editor | Terminal-first CLI, plus editor integrations and a desktop app |
| Parallel sessions | Git worktree workspaces built into the UI | Manual worktrees or nested desktop sessions |
| Extensibility | TypeScript extensions, skills, themes, packages | Subagents, plan mode, MCP, built-in review tooling |
| Philosophy | Minimal core, you assemble the rest | Integrated agent that handles more by default |
One widely cited independent benchmark from Composio ran both agents on the same 30-task set and found Claude Code finished a hair faster on median time (122.7 seconds vs Pi's 132.2), but Pi passed more tasks (20 of 30 vs 16 of 30), made more tool calls, and used roughly 25% fewer tokens per task. The spend gap followed: $0.56 total for Pi versus $3.12 for Claude Code, or about $0.028 per successful task against $0.195, roughly a 7x difference in cost-per-success on that specific test. I'd treat the exact multiplier as benchmark-specific rather than gospel, but the direction matches what you'd expect from a sub-1,000-token prompt versus a five-figure one.
What that number actually means in practice: Pi rewards someone willing to build their own harness and tune it for a narrow, repeated task. Claude Code rewards someone who wants the agent to carry more of the process out of the box (subagents, plan mode, review, the works) and is fine paying for that convenience. Neither is objectively "better." They're optimizing for different users.
Honestly, probably not yet, and not because ThinkRail is bad. If you're already deep into Claude Code workflows (using its usage limits and cost sensibly, relying on subagents, happy with the review tooling), there's no urgent reason to rip that out for a 0.2.0 incubator project sitting at roughly 3,300 GitHub stars and 174 open issues.
Where ThinkRail earns a look: you're already running Pi from the terminal and want a real editor and worktree management instead of juggling tmux panes, or you're cost-sensitive and want to see exactly what a provider-agnostic agent costs per session without committing to one vendor's bundled pricing. It's also worth watching simply because JetBrains backing it means actual engineering resources behind an agent IDE that isn't trying to lock you into a single model provider. See our broader look at how Claude Code, Codex, and Cursor are converging on similar ideas from different directions.
My honest read: the worktree-per-agent pattern is the right instinct, and I expect it to show up in more tools over the next year. ThinkRail just got there first in a polished, shipped form. The AI-generated-reading docs are a self-inflicted wound JetBrains should fix, because the actual engineering here doesn't deserve that first impression.
ThinkRail is a free, open-source agentic IDE JetBrains released in August 2026. It wraps the Pi coding agent in a graphical interface with git-worktree-based workspaces, a Monaco code editor, and a spec graph for persistent project context.
Pi is a minimalist open-source AI coding agent created by developer Mario Zechner, now maintained under the earendil-works org after a May 2026 transfer to Earendil Inc, a company co-founded by Flask creator Armin Ronacher. It runs a sub-1,000-token system prompt with just four built-in tools and is extended through TypeScript plugins.
Yes. ThinkRail is released under the Apache 2.0 license on GitHub, and Pi itself is MIT-licensed. You still pay separately for whatever model provider you connect through Pi's auth, whether that's JetBrains AI or another vendor.
No. As of the 0.2.0 release in October 2026, ThinkRail is built specifically around the Pi coding agent and doesn't support swapping in Claude Code or other agent CLIs as the backend.
Pricing depends entirely on the model provider you connect, since both are agent harnesses rather than models. One independent Composio benchmark on a 30-task set measured Pi at roughly $0.028 per successful task versus $0.195 for Claude Code, about a 7x difference, though that's one benchmark and not a universal number.
ThinkRail needs Bun 1.4.4, Node.js 22.19 or newer, and git available on your PATH. It installs as a native desktop app on macOS, Windows, and Linux, or as a CLI via an install script, with stable and nightly update channels.
Yes. Because Pi handles model access across more than fifteen providers, ThinkRail works with JetBrains AI or any provider Pi supports through its own authentication system, rather than locking you into a single model vendor.
New AI tools, automation workflows, and course drops — straight to your inbox. Join 2,400+ builders.
Sebastian Raschka's free 11-hour video course builds a reasoning model from scratch in Python and PyTorch, covering GRPO RL, inference scaling, and distillation.
Theo Browne open-sourced tstack: 9 Claude Code and Codex skills like full-send, council, and babysit-pr that file, review, and merge PRs on their own.
GPT-6.1 Terra launched Oct 26, 2026 at $1/$5 per million tokens, scoring 50.3% on Terminal-Bench 4.0. Here's how it stacks up against Claude Sonnet 5.5 and Haiku 5.5.
Comments