ThinkRail
thinkrail website workspace/website · from main

<!-- README.md -->

JetBrains incubator Apache-2.0 open source

ThinkRail

The worktree IDE for the pi coding agent.

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.

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

One self-contained binary. macOS (Apple Silicon) · Linux arm64 / x64 · Windows x64.

Star on GitHub See it in action

<!-- why.md -->

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.

<!-- features/worktrees.md -->

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.

<!-- features/editor.md -->

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.

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

<!-- features/agent-chat.md -->

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 a desktop-and-mobile client for 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:

  1. Engine host (packages/server) — createServer() runs an HTTP+WS host plus an AgentSessionManager: one in-process pi session per tab.
  2. The wire (packages/contracts) — the typed, versioned protocol between host and UI. Types only.
  3. 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.

<!-- features/specs.md -->

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

Install

# one line: downloads the right build, verifies its SHA-256, puts `thinkrail` on your PATH
curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash

# nightly channel, or pin a version
curl -fsSL … | bash -s -- --channel nightly
curl -fsSL … | bash -s -- --version 0.2.0

# then
thinkrail         # launch — opens the IDE in your browser
thinkrail update  # grab the latest build later
  • Prebuilt: macOS (Apple Silicon), Linux arm64 + x64, Windows x64.
  • Needs: git on PATH and an authenticated pi provider — the agent runs against your real credentials.
  • Prefer manual? Grab a binary + SHA256SUMS from the releases page, verify, chmod +x, done. App state lives under ~/.thinkrail.