JetBrains' ThinkRail: Lightweight IDE for AI Coding Agents with Git Worktree Isolation

What ThinkRail Is and Why It Exists

Pi is a terminal-based coding agent that can call models, read and write files, execute commands, and be extended via Skills. ThinkRail adds a graphical IDE on top: Pi still executes tasks underneath, while the UI provides a workspace, editor, terminal, and review interface so a developer can chat with the agent and inspect its code changes side by side.

The JetBrains team explains that Pi is flexible but has a learning curve; even experienced users may find the terminal workflow awkward. ThinkRail aims to lower the entry barrier while preserving Pi's customizability and adding Git and GitHub collaboration.

In practice, after an agent receives a task, the human still needs to decide which branch it works on, review its changes, and feed feedback back. ThinkRail places these steps in a single workbench and uses spec documents saved alongside the code to record project requirements for later tasks.

One Requirement, One Isolated Workspace

Suppose you need to add an export feature while another agent fixes a login bug. Both tasks might touch shared components. In ThinkRail you can create two independent workspaces from the same Git repository. Each workspace maps to a git worktree with its own branch and working directory; chat, files, and terminal follow the workspace. The export feature is edited in one directory, the login fix in another, and you decide what to merge after review.

A workspace can run multiple Pi sessions, each choosing its own model. Therefore, tasks that must modify different files need separate workspaces; merely opening multiple chats in the same workspace still shares the same file set.

ThinkRail also allows working directly in the original project directory or attaching an existing worktree. Choosing the original directory means changes land there — not all operations are automatically isolated.

The isolation is at the Git working-directory level. ThinkRail's architecture notes state that Pi runs inside the host process without process-level crash isolation. Worktrees do not automatically provision separate databases or service ports; parallel project runs still require manual environment setup.

After the Agent Finishes, Review Its Changes Turn by Turn

The workspace editor uses Monaco , supporting file opening, split-view code reading, and terminal execution. When you need full IDE capabilities, you can open the worktree in your locally installed IDE.

The author's hands-on session shows the model DeepSeek V4.1 Flash in use. Because Pi was already configured with some domestic models, they were available without reconfiguration.

A key feature in version 0.2.0 is turn-by-turn review . After the agent completes a round of edits, the UI shows the number of changed files, lines added and removed, and provides a Review turn entry that opens all files involved in that turn.

These statistics come from workspace snapshots taken by the host at task start and end. Whether the agent edits files via shell or runs a formatter, any change captured in the snapshot is diffable — no need to rely on the agent's final summary.

Inspecting packages/server/src/git/snapshot.ts reveals the implementation: a temporary Git index records file state, then write-tree creates the snapshot. This does not commit changes to the branch nor touch the user's actual staging area.

Two review views differ in scope. The single-turn view is currently read-only ; switching to the branch-level All changes view enables hunk-level keep, discard, or sending a diff back to the agent for further work. Marking a file as reviewed does not imply tests pass; business logic still requires manual verification.

Where Do Project Requirements Come From Next Time?

Diffs show how code changed but not why. For example, who uses the export feature, what is the record limit, how are sensitive fields handled? If such requirements live only in a chat, they must be rediscovered later.

ThinkRail uses spec documents saved with the code to capture these decisions. Project goals go in goal-and-requirements.md, overall architecture in architecture.md, and module-specific specs in SPEC.md files placed next to the modules. Documents are linked via identifiers, parent-child relations, and dependencies, displayed as a spec tree in the UI.

Continuing the export example, permissions, quantity limits, and sensitive-field handling are written into the export module's spec. Future adjustments give the agent a reference; when requirements change, the document is updated.

The stable spec-graph module provides dedicated tools: spec_grep for search, spec_graph for viewing document relationships, plus create, delete, and validate utilities. Notably, spec_update only updates the document's front-matter metadata; the body is still edited via Pi's regular file read/write tools.

The README's vision of learning the project through use currently materializes as these file-based specs and reusable Skills. Full extension support for the IDE to create more capabilities remains a future direction in the 0.2.0 README.

Maintaining specs takes time. Trivial prompt tweaks don't warrant a full documentation suite; only decisions involving permissions, interface contracts, or module responsibilities justify persistent records. Outdated docs risk leading the agent to follow incorrect requirements.

Getting Started

ThinkRail offers a desktop app and a CLI that launches a browser UI. Prerequisites: Git must be executable locally, and a model service must be configured — either JetBrains AI or any provider supported by Pi (the demo used DeepSeek V4.1 Flash).

Desktop builds cover macOS Apple Silicon, Windows x64, and Linux x64/ARM64.

After opening the app, select a local Git repository via the Open project entry.

The author advises not to rush to switch IDEs; tools are just tools. However, for developers already using Pi who want centralized change management, ThinkRail is worth a try — it's a lightweight piece of software with low trial cost.

Project repository: https://github.com/JetBrains/thinkrail

References

[1] Turn-by-turn review in 0.2.0: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/

[2] spec-graph module: https://github.com/JetBrains/thinkrail/tree/v0.2.0/packages/spec-graph