ThinkRail from JetBrains

50 points by wilsonjholmes a day ago on hackernews | 78 comments

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

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

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

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

---
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.

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.