JetBrains open-sourced ThinkRail over the weekend: an agentic IDE, Apache-2.0, on GitHub, with more than a thousand stars in its first day on the trending list. The interesting part is not that an IDE vendor shipped an AI product. It is whose brain is inside. The engine is `pi`, Earendil's minimal, extensible coding-agent harness, running in-process.
The division of labour is unusually explicit in the README. `pi` owns models, skills, context compaction, cost and session state. ThinkRail owns the workspace, the editor and "the wire" — the typed protocol between host and interface. Then comes the sentence that reads like a shot at the competition: ThinkRail never assembles prompts behind your back.
Every workspace is a git worktree
What ThinkRail actually sells is isolation. A project is any local git repository; a workspace is a `git worktree` cut from it, with its own branch and its own working directory. Three agents can run in parallel and one agent's mess stays on its branch while `main` stays clean until you say otherwise. Files, diffs, terminals and chats are all scoped to the active worktree; switching between them reloads nothing and leaks nothing across.
Around that sits a real editing surface: Monaco tabs, a file tree, a live git diff of the workspace branch, real PTYs for running tests while the agent keeps typing, and several concurrently streaming chat sessions — model selectable per session, tokens and cost ticking in the header, a running turn steerable or a follow-up queued rather than waiting for the agent to finish. The agent can ask structured questions back inside the chat.
Specs as the memory that survives the session
Every module carries a `SPEC.md` with YAML frontmatter — id, type, status, parent — linking it into a graph of goal, architecture, modules and tasks. A bundled extension gives `pi` a set of `spec_*` tools to search, navigate and maintain that graph, and a Specs tab renders the live graph for the active worktree. The specs are plain markdown next to the code and versioned with it, so intent is readable after the context window has moved on; the agent is expected to keep them honest as it builds.
Three rings, mobile first
Underneath: a `Bun.serve` HTTP and WebSocket host with an `AgentSessionManager` holding one in-process `pi` session per tab; a contracts package as the typed, versioned wire; and a React 19 client (Zustand, Tailwind v4) that depends only on the contracts and therefore ships independently of the host. The interface is deliberately mobile-first, which fits the deployment shape it implies: the agent lives on a machine, and you drive it from whatever screen is at hand. It ships as a desktop app built on Electrobun and as a CLI that opens the same app in a browser.
The edges worth knowing
This is a JetBrains InnovationHub project, not an IntelliJ plugin, and it is early. You need `git` and your own authenticated `pi` provider — you pay the model vendor, not JetBrains. Signing is uneven: Windows CLI and desktop setup are signed, the macOS CLI is signed but not yet notarised, Linux artifacts are unsigned, and there is no Intel macOS build, so Gatekeeper can block the app outright. Telemetry goes to PostHog EU; basic events — launches, chat creation, accepted message sends, provider connections — are on by default, and `--no-analytics` suppresses only the additional tier.
Why it matters
The agent tooling market has reorganised itself twice in a year: agents as terminal tools, then as plugins inside existing editors, now as environments of their own. Differentiation moves with it — away from language intelligence, which was JetBrains' business for twenty-five years, toward operational questions. How many agents can run at once without overwriting each other? What does an agent still know after the session ends? How does a human review what happened while it was working?
ThinkRail's answers — worktrees, a spec graph, a review diff — are unglamorous and sound. The more interesting decision is ceding the model layer entirely: no JetBrains model, a third-party harness hosted in-process, competing with the company's own flagship IDE from inside the same house. Whether that is humility or time pressure will be visible in how fast extensions and a stable 1.0 arrive.
