JetBrains 开源智能体 IDE ThinkRail

JetBrains InnovationHub Apache-2.0 open source

The agentic IDE that gets better every time you use it.

Open a repo as a project. Cut isolated git-worktree workspaces. Pair with a real agent across Monaco tabs, terminals, and diffs — while your project's intent lives in a spec graph the agent actually reads.

macOS

Apple Silicon

Browser UI via command line

Install the local launcher; run thinkrail to open the browser UI.

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

Windows

Windows x64

Browser UI via command line

Install the local launcher; run thinkrail to open the browser UI.

PowerShell

irm https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.ps1 | iex

Command Prompt (cmd)

powershell -c "irm https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.ps1 | iex"

WSL

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

Linux

Ubuntu 24.04+

Browser UI via command line

Install the local launcher; run thinkrail to open the browser UI.

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

Why ThinkRail

Agents deserve worktrees, not your working tree.

Every workspace is a real git worktree — its own branch, its own cwd. Run several agents in parallel; each one's mess stays on its branch, and main stays clean until you say otherwise.

Specs are the ground truth.

ThinkRail is built spec-first, and so are your projects: a connected graph of spec files lives beside the code, and the agent reads, searches, and maintains it with dedicated tools. Intent survives the session.

A thin host, a real engine.

The pi coding agent runs in-process and owns models, skills, compaction, and cost. ThinkRail owns the workspace, the editor, and the wire — it never assembles prompts behind your back.

Projects → workspaces

A project is any local git repo. A workspace is a git worktree cut from it — created in one click, listed in the rail, disposable without ceremony.

# one repo, three parallel lines of thought
~/code/my-repo                        ← project
└─ ~/.thinkrail/worktrees/
   ├─ workspace-1   ⎇ feature/auth      agent A building
   ├─ workspace-2   ⎇ fix/flaky-test    agent B fixing
   └─ workspace-3   ⎇ spike/ideas       you, exploring

Own branch + cwd per workspace — files, diffs, terminals, and chats all scope to it.
Switch workspaces instantly; nothing reloads, nothing leaks across.
Merge the good one, delete the rest. Your repo never noticed the chaos.

A real IDE around the agent

Watch the agent work — or work beside it — without leaving the page.

Monaco editor tabs

The VS Code editor engine: syntax everywhere, rendered markdown with a source toggle, file tabs per workspace.

Files tree

The active worktree at a glance — like the rail on the right of this very page.

Changes

A live git diff of the workspace branch, so you review the agent's work as it lands.

Terminals

Real PTYs scoped to the worktree — run the tests yourself while the agent keeps typing.

Chats that stream like the engine thinks

This transcript is a real pi session, captured in ThinkRail while it worked on its own repo:

Quick tour: what is ThinkRail, and what are the three rings of its architecture? Keep it brief.

read goal-and-requirements.md · architecture.md

ThinkRail is the agentic IDE built around the pi coding agent — a thin host that runs pi in-process and bridges it to a rich UI, while pi owns models, skills, compaction, cost, and session state.

The three rings:

Engine host (packages/server) — createServer() runs an HTTP+WS host plus an AgentSessionManager: one in-process pi session per tab.
The wire (packages/contracts) — the typed, versioned protocol between host and UI. Types only.
UI client (apps/web) — mobile-first React that ships independently and dials any host over the wire.

Done 5s · 25.9k tok · $0.17

Several sessions per workspace, streaming concurrently.
Pick the model per session; tokens and cost tick live in the header.
Steer a running turn or queue a follow-up — no waiting for the agent to finish.
Interactive tools: the agent can ask structured questions back, right in the chat.

Specs are first-class

Every module carries a SPEC.md with frontmatter linking it into a graph — goal, architecture, modules, tasks. The bundled pi-spec-graph extension gives the agent spec_* tools to search, navigate, and maintain it, and the Specs tab renders the live graph of your worktree:

ThinkRail — product goal and scope main spec

ThinkRail — top-level architecture arch

Engine host (server library) module

agent — in-process pi sessions submodule

Web UI client module

---
id: module-server
type: module-design
status: active
parent: architecture
---

Plain markdown, plain frontmatter, versioned with the code — reading the specs is enough to understand an area and formulate the next task. The agent keeps them honest as it builds.

Install

Choose your platform and start working.

macOS Apple Silicon

Windows Windows x64

Linux Ubuntu 24.04+

Linux: extract the archive, run ./installer, and check the native library requirements.

Browser UI via command line

Install the local launcher, then run thinkrail to open the browser UI.

macOS, Linux, WSL

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

Windows PowerShell

irm https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.ps1 | iex

Command Prompt

powershell -c "irm https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.ps1 | iex"

Requires git and an authenticated pi provider. See all releases and advanced CLI options.

Open source, spec-first

ThinkRail is a JetBrains InnovationHub project, licensed Apache-2.0. The repo is developed spec-first — the top-level specs are the product's ground truth, and this website is itself a module with a SPEC.md.

GitHub Issues Contributing Code of Conduct Releases