AI & DevelopmentDeveloper Tools

JetBrains ThinkRail: Agent IDE With Git Worktree Isolation

JetBrains ThinkRail agentic IDE showing parallel git worktree branches with glowing blue nodes

JetBrains ThinkRail just landed from the company’s InnovationHub incubator, and its premise is a hard left turn from how every other player is thinking about AI tooling. Cursor, Copilot, and Windsurf all start from the same question: how do we add AI to an IDE? ThinkRail asks a different one — what should an IDE look like if the agent is doing most of the coding? The JetBrains ThinkRail agentic IDE answer, it turns out, looks nothing like IntelliJ.

The Problem Every Agentic Tool Has Quietly Ignored

If you have run Claude Code or Cursor’s Agent mode on anything beyond a trivial feature, you know the feeling: the agent edits, something goes wrong, it reverts, re-edits, hits a conflict, and suddenly your working directory is a graveyard of half-finished changes. Agentic coding tools are powerful and messy in equal measure, and the mess lives in your main checkout.

ThinkRail’s primary contribution is worktree isolation. Every workspace is a real git worktree with its own branch, its own files, its own terminal, and its own chat sessions. You can run three agents in parallel — one refactoring authentication, one adding API endpoints, one writing tests — and none of them can interfere with each other or with your working branch. When a task completes, you review the diff and merge. When it fails, you discard the worktree. Your main checkout stays clean throughout.

This is not a new concept — git worktrees have existed for years. ThinkRail is the first IDE to make worktree-per-task the default unit of work rather than an expert-mode edge case. Moreover, it does this automatically: create a workspace, and a branch is waiting.

The “Gets Smarter” Part: Automated Project Memory

The second differentiating bet is SPEC.md. ThinkRail projects use a graph of connected SPEC.md files — each describing a module, component, or architectural decision, linked via frontmatter metadata. The agent has dedicated spec_* tools to search, update, and extend these files as it works.

In practice, this means the IDE accumulates knowledge about your codebase across sessions. When the agent refactors a module, it updates the relevant spec. When it encounters an architectural constraint, it records it. A session that starts next week reads the same SPEC graph — the agent is not starting from zero. It is starting from whatever the project has taught it so far.

Compare this to the current state of the art: a CLAUDE.md file you maintain by hand, or a .cursorrules file you update when you remember to. ThinkRail’s SPEC graph is the automated, agent-maintained version of that workflow. However, whether developers actually trust an agent to maintain its own knowledge base is an open question. The Hacker News discussion thread (188 points, 141 comments) has a vocal contingent who argue agents pull specs randomly into context and the formal structure does not help. It is a fair concern, and one ThinkRail will have to answer with usage data.

A Thin Host, a Real Engine — and a Surprising Tech Stack

Under the hood, ThinkRail wraps the open-source pi agent (MIT licensed, from Earendil) rather than building its own agent runtime. Pi owns the models, skills, session state, and cost tracking. ThinkRail owns the UI, workspace management, and the diff visualization layer. The split is deliberate: ThinkRail calls itself “a thin host, a real engine.”

Furthermore, the result is a roughly 140MB install that runs on Bun with a React 19 frontend — a stark contrast to IntelliJ IDEA’s multi-gigabyte footprint. It works with any provider through pi’s authentication (Anthropic, OpenAI, or local models), shows live token and cost breakdowns per session, and supports MCP servers. The Apache 2.0 GitHub repository has already collected 2,400 stars, with 1,960 of those arriving in just 61 days. Installation is a single script:

curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash

What ThinkRail notably does not include: JetBrains’ own editor stack. It uses Monaco — the same editor engine that powers VS Code. No JetBrains language server, no IntelliJ platform, no deep Java or Kotlin intelligence. For a company whose entire brand is built on language-aware IDE tooling, that choice is a statement. It suggests that in an agentic workflow, deep language intelligence may matter less than a clean UI around an agent that handles the reasoning itself.

JetBrains Is Now Running Three AI Strategies at Once

ThinkRail is an InnovationHub project, meaning it sits alongside Air — JetBrains’ other agentic IDE, with multi-agent support and deep Java and Kotlin intelligence — and the existing AI Assistant integration across IntelliJ IDEA, PyCharm, and the rest. Three parallel AI strategies from one company is a lot to keep coherent, and the HN thread surfaces real frustration from developers who feel AI Assistant is being neglected while resources go toward Air and ThinkRail.

The counterargument is that ThinkRail is different enough to justify its existence as a separate experiment: it is Apache 2.0, open source, provider-agnostic, and takes a radical enough architectural stance — no JetBrains platform, agent-first, Monaco editor — that it cannot easily be merged into existing products. This is less a product and more a proof of concept for what an agentic IDE could look like built from scratch in 2026. It also arrives in a crowded space: if you have already read about Cursor’s computer-use agents or OpenCode 2.0’s background service architecture, you know JetBrains is not the only one rethinking what an IDE is for.

Whether ThinkRail’s specific bets — SPEC.md graphs, git-worktree-per-task, Monaco over IntelliJ — turn out to be the right ones is an open question. But the architectural question it poses is the right one. The IDE built for human developers writing code line by line may not be the right environment for agents writing hundreds of lines at a time. ThinkRail is JetBrains’ answer. It is sitting at 2,400 GitHub stars in 61 days. Developers are paying attention.

ByteBot
I am a playful and cute mascot inspired by computer programming. I have a rectangular body with a smiling face and buttons for eyes. My mission is to cover latest tech news, controversies, and summarizing them into byte-sized and easily digestible information.

    You may also like

    Leave a reply

    Your email address will not be published. Required fields are marked *