# ThinkRail

Podium publishes this catalog and sells an agent development environment. Podium chooses the products, criteria, sources and wording, so treat these pages as vendor-authored research. Check important claims against the linked primary sources. The same evidence rules apply to Podium and its competitors, but they do not remove this conflict of interest.

Page: https://adecomparison.com/ade/thinkrail/
Website: https://thinkrail.ai/
Research: covered

Method: https://adecomparison.com/method/

Rank by must-haves met, then preferences, then name. Read each finding's checked date. Findings stay published after their scheduled recheck. Checks over six months old may be outdated.

## thinkrail:ACC-01

Finding: Desktop apps ship for macOS 14+ (Apple Silicon and Intel), Windows x64 and Linux x64/ARM64; the complete install matrix omits native phone apps and editor extensions. The thinkrail CLI opens the same app in any browser, the web UI adapts to phone viewports over Tailscale, and notifications arrive via desktop alerts plus in-app waiting markers. Same-task state rebuilds on another surface, but running execution does not hand off.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

The complete install list omits native phone apps and editor extensions. Cross-device state rebuilds; running execution stays on the originating host.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/introducing-thinkrail/
Locator: Install; What is next
Finding: ThinkRail is an agentic IDE for the Pi coding agent that complements its CLI. Desktop installers for macOS, Windows x64 and Linux x64/ARM64, or a CLI host that opens a browser tab. Every working session operates on a separate git branch merged only after review; LLM providers are configured in Settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-1-release/
Locator: One box; Your own model server; pi packages; closing channels
Finding: Command palette finds chats, workspaces, commands and settings. Custom OpenAI chat-completions servers (Ollama, LM Studio, vLLM, llama.cpp presets) are saved into pi models.json. pi packages install from Settings for the user or a repository. Post notes ThinkRail is backed by JetBrains and links X (@ThinkRailAI), YouTube, TikTok, Discord and the GitHub repository.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-pi-skills-and-desktop-apps/
Locator: Pi compatibility; The Skills window; Desktop apps
Finding: ThinkRail embeds its own pi coding agent as a library running inside ThinkRail’s own process and shares pi’s ~/.pi folder, so CLI and app sessions keep history both ways. Skills and extensions from pi, Claude, Codex, Copilot and Gemini project folders are reused with per-chat switches. Desktop apps packaged with Electrobun run identically to the CLI browser host.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail
Locator: Repository header and metadata
Finding: Public repository in the JetBrains organisation, default branch main, pushed 2026-11-12. 8,189 stars, 518 forks and 257 open issues observed 2026-11-12. Licensed Apache-2.0; homepage thinkrail.ai.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/contracts/src/wsProtocol.ts
Locator: session.list / session.getMessages / session.created; host requestReplayCache repairs missed deltas
Finding: Hydrate-then-stream: clients rebuild projects, workspaces, sessions and transcripts on reload, second tab, phone or host restart; reconnect repairs missed deltas.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/apps/web/src/notifications/attentionNotificationEngine.ts
Locator: rising-edge attention gate per session; desktopNotifications; unread holds
Finding: Attention engine with per-session unread holds plus desktop notifications.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/editors/editors.ts
Locator: GUI_CANDIDATES vscode/emacs; JETBRAINS_CANDIDATES bins; TERMINAL vim; no extension packaging
Finding: Fixed external-editor launcher list (VS Code, Emacs, JetBrains IDEs, Vim). No ThinkRail editor extension ships.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/apps/web/src/lib/viewport.ts
Locator: PHONE_QUERIES pointer:coarse and max-width:767px; usePhoneViewport hook
Finding: Phone-viewport detection adapts the UI below 767px width.
Retrieved: 2026-11-12

## thinkrail:ACC-02

Finding: The only harness is pi, run in-process with no second runtime. Model choice comes from pi provider auth plus JetBrains AI through the user-owned central CLI and user-added OpenAI-compatible servers (1,639 provider/model pairs in the pi 1.5.1 catalogue). Other coding-agent CLIs are only detected as provider-setup signals, never run as harnesses; mixed-harness operation is excluded by the single-engine design.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Single-engine product: no second harness exists and mixed-harness operation is excluded.

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-1-release/
Locator: One box; Your own model server; pi packages; closing channels
Finding: Command palette finds chats, workspaces, commands and settings. Custom OpenAI chat-completions servers (Ollama, LM Studio, vLLM, llama.cpp presets) are saved into pi models.json. pi packages install from Settings for the user or a repository. Post notes ThinkRail is backed by JetBrains and links X (@ThinkRailAI), YouTube, TikTok, Discord and the GitHub repository.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-pi-skills-and-desktop-apps/
Locator: Pi compatibility; The Skills window; Desktop apps
Finding: ThinkRail embeds its own pi coding agent as a library running inside ThinkRail’s own process and shares pi’s ~/.pi folder, so CLI and app sessions keep history both ways. Skills and extensions from pi, Claude, Codex, Copilot and Gemini project folders are reused with per-chat switches. Desktop apps packaged with Electrobun run identically to the CLI browser host.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/central-integration.md
Locator: The chain; Quota chain
Finding: JetBrains AI models reach ThinkRail through the user-owned central CLI with a recurring AI-credit quota; sign-in, status and quota orchestration span the provider card and shell, with quota snapshots on a 1–3600 second cadence (30 seconds by default).
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/pi-compatibility.md
Locator: Last re-check
Finding: Host tracks pi releases with per-upgrade re-checks (pi 1.5.2 verified against the installed dist). Bundled chat catalogue holds 1,639 provider/model pairs in pi 1.5.1 (66 added, 19 removed); unavailable models follow the existing selection rules.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/auth/detectAccounts.ts
Locator: detectClaudeCode/Codex/Copilot read own config files as setup signals; pi performs the login
Finding: Third-party CLIs are read as provider-setup signals only; sign-in stays pi’s own flow.
Retrieved: 2026-11-12

## thinkrail:ACC-03

Finding: ThinkRail uses provider API keys and Pi's native OAuth login, including Anthropic subscription credentials recognized by the embedded runtime. External CLI accounts are setup signals rather than borrowed credentials; there is no ThinkRail credit system.

Verification: sourced
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: Targeted first-party source check 2026-11-13. New implementation findings are pinned to 1bc1a9bc5b0bb9d2c029da32125fadf0bd29d544. Unchanged atomic answers retain the individual source dates and revisions in their cited evidence.

This source pass establishes only the named atomic answers. Other parts retain their documented source gaps; no hands-on test was performed.

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-1-release/
Locator: One box; Your own model server; pi packages; closing channels
Finding: Command palette finds chats, workspaces, commands and settings. Custom OpenAI chat-completions servers (Ollama, LM Studio, vLLM, llama.cpp presets) are saved into pi models.json. pi packages install from Settings for the user or a repository. Post notes ThinkRail is backed by JetBrains and links X (@ThinkRailAI), YouTube, TikTok, Discord and the GitHub repository.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/
Locator: Every turn gets a receipt; MCP servers, finally
Finding: Turn receipts (files changed plus Review turn button) and a stacked Changes tab with per-hunk Keep, Revert and Ask agent plus Next-unreviewed (J). MCP runs on pi’s built-in engine with presets (Context7, DeepWiki, Linear read-only, Sentry, Playwright); secrets must be ${VAR} or !command and repo .pi/mcp.json entries need per-entry approval; data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/central-integration.md
Locator: The chain; Quota chain
Finding: JetBrains AI models reach ThinkRail through the user-owned central CLI with a recurring AI-credit quota; sign-in, status and quota orchestration span the provider card and shell, with quota snapshots on a 1–3600 second cadence (30 seconds by default).
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/pi-compatibility.md
Locator: Last re-check
Finding: Host tracks pi releases with per-upgrade re-checks (pi 1.5.2 verified against the installed dist). Bundled chat catalogue holds 1,639 provider/model pairs in pi 1.5.1 (66 added, 19 removed); unavailable models follow the existing selection rules.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/auth/detectAccounts.ts
Locator: detectClaudeCode/Codex/Copilot read own config files as setup signals; pi performs the login
Finding: Third-party CLIs are read as provider-setup signals only; sign-in stays pi’s own flow.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/1bc1a9bc5b0bb9d2c029da32125fadf0bd29d544/packages/server/src/agent/anthropicExtraUsage.ts#L1-L40
Locator: anthropicExtraUsage.ts anthropicSubscriptionAuthActive; auth/providerLogin.ts startLogin; auth/detectAccounts.ts known subscription plans
Finding: ThinkRail starts Pi's own OAuth login flow, and its runtime explicitly recognizes active Anthropic subscription OAuth credentials for extra-usage warnings. Detected Claude/Codex CLI account plans are setup signals, not borrowed credentials. This establishes subscription use through the embedded Pi provider login rather than a separate CLI runtime.
Retrieved: 2026-11-13

## thinkrail:ACC-04

Finding: A first-run wizard (intro, privacy question, Connect a model) drops the user on Start/Open project; Start a new project creates an empty git repo, and Clone repository accepts a Git URL. Any local git repo opens as a project, chats without a project work in scratch folders, and GitHub works through the user’s git credentials and gh CLI. No vendor-cloud or user-server hosting path exists.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Local-only product: no vendor-cloud or BYO-server onboarding exists; remote-host dialling is described as future work.

Source: https://thinkrail.ai/blog/introducing-thinkrail/
Locator: Install; What is next
Finding: ThinkRail is an agentic IDE for the Pi coding agent that complements its CLI. Desktop installers for macOS, Windows x64 and Linux x64/ARM64, or a CLI host that opens a browser tab. Every working session operates on a separate git branch merged only after review; LLM providers are configured in Settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

## thinkrail:ACC-05

Finding: The product-owned thinkrail CLI is a launcher with an exhaustive inventory: open, update and uninstall plus connection flags; it exposes no agent operations. The engine-to-UI wire is internal (/ws plus /health and static routes), with no public API, SDK, MCP server or webhooks in the pinned release.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

All agent operations are UI-driven. The CLI inventory is complete and omits them; no programmable surface exists.

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/apps/cli/src/args.ts
Locator: USAGE string; exhaustive parseArgs (unknown options throw); SUBCOMMANDS update/uninstall
Finding: Complete CLI inventory: launch flags plus update and uninstall subcommands only. No session, task, steering or review operations exist in the launcher.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/host/server.ts
Locator: fetch handler: /ws, /health, static and file/font routes only; no REST router
Finding: The host exposes only the internal /ws wire, /health and static/file routes. No public REST API, SDK surface, MCP server transport or webhooks exist in code.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/agent/mcp/sessionHost.ts
Locator: MCP_CONFIRM_ALWAYS; confirm() on data-changing calls with no-UI-attached fallback; allow once/chat/always
Finding: MCP confirmation is product code: data-changing calls confirm with Deny, Allow once, Allow in this chat or Always allow, and fail closed with no UI attached.
Retrieved: 2026-11-12

## thinkrail:ACC-06

Finding: MCP servers come from pi mcp.json and Settings with presets, per-chat visibility and in-chat confirm for data-changing calls. pi packages (extensions, skills, prompts) install from npm, git or local folders for the user or a repo with per-item switches. Skills import from Claude, Codex and other agents’ folders; repo-defined resources stay off until a per-project trust grant, and repo MCP entries need per-entry approval.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)



Source: https://thinkrail.ai/blog/thinkrail-0-3-1-release/
Locator: One box; Your own model server; pi packages; closing channels
Finding: Command palette finds chats, workspaces, commands and settings. Custom OpenAI chat-completions servers (Ollama, LM Studio, vLLM, llama.cpp presets) are saved into pi models.json. pi packages install from Settings for the user or a repository. Post notes ThinkRail is backed by JetBrains and links X (@ThinkRailAI), YouTube, TikTok, Discord and the GitHub repository.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-pi-skills-and-desktop-apps/
Locator: Pi compatibility; The Skills window; Desktop apps
Finding: ThinkRail embeds its own pi coding agent as a library running inside ThinkRail’s own process and shares pi’s ~/.pi folder, so CLI and app sessions keep history both ways. Skills and extensions from pi, Claude, Codex, Copilot and Gemini project folders are reused with per-chat switches. Desktop apps packaged with Electrobun run identically to the CLI browser host.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/
Locator: Every turn gets a receipt; MCP servers, finally
Finding: Turn receipts (files changed plus Review turn button) and a stacked Changes tab with per-hunk Keep, Revert and Ask agent plus Next-unreviewed (J). MCP runs on pi’s built-in engine with presets (Context7, DeepWiki, Linear read-only, Sentry, Playwright); secrets must be ${VAR} or !command and repo .pi/mcp.json entries need per-entry approval; data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/agent/mcp/sessionHost.ts
Locator: MCP_CONFIRM_ALWAYS; confirm() on data-changing calls with no-UI-attached fallback; allow once/chat/always
Finding: MCP confirmation is product code: data-changing calls confirm with Deny, Allow once, Allow in this chat or Always allow, and fail closed with no UI attached.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/agent/skillAdmission.ts
Locator: trusted / piResourceTrust per project; untrusted default
Finding: Project resources load only after per-project trust grants (trusted, piResourceTrust); untrusted is the default.
Retrieved: 2026-11-12

## thinkrail:ACC-07

Finding: The desktop app is an Electrobun package: a native system-webview shell around the same engine host the CLI uses. No native mobile client exists (apps/ holds cli, desktop, web and website only; the install matrix omits mobile) and no hybrid construction exists beyond the system-webview shell.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-05-11
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

No native mobile client or hybrid construction exists to classify.

Source: https://thinkrail.ai/blog/thinkrail-pi-skills-and-desktop-apps/
Locator: Pi compatibility; The Skills window; Desktop apps
Finding: ThinkRail embeds its own pi coding agent as a library running inside ThinkRail’s own process and shares pi’s ~/.pi folder, so CLI and app sessions keep history both ways. Skills and extensions from pi, Claude, Codex, Copilot and Gemini project folders are reused with per-chat switches. Desktop apps packaged with Electrobun run identically to the CLI browser host.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail
Locator: Repository header and metadata
Finding: Public repository in the JetBrains organisation, default branch main, pushed 2026-11-12. 8,189 stars, 518 forks and 257 open issues observed 2026-11-12. Licensed Apache-2.0; homepage thinkrail.ai.
Retrieved: 2026-11-12

## thinkrail:PLAN-01

Finding: Projects, workspaces and scratch chats are created locally from prompts, and asking for work in a side workspace makes the agent start the workspace and its chat itself. External intake is repository-shaped (clone URL, attached worktrees) with GitHub PR metadata read back into the topbar and PR round-trips through gh. No issue tracker, sync, or chat/git triggers exist in docs or the pinned release.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

No external issue-tracker relationship exists; PR round-trips are GitHub-only and partial on GitLab.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-workspaces/
Locator: Create an isolated workspace; Work safely on many tasks at the same time
Finding: Workspaces are git worktrees under ~/.thinkrail/worktrees with their own branch and cwd; parallel agents stay on their branches and merge back (or open a PR) only on request.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/workspaces/workspaces.ts
Locator: status available/detached; settledOverride settled/active; Default kind non-settleable; external attach
Finding: Flat workspace model with available/detached status and settled/active lifecycle. No epics, labels, priorities, queues, blockers, readiness gates or dependencies in code.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src
Locator: Searched packages/server, apps/* and packages/* at v0.3.2 for schedul|cron|trigger|recur|setInterval-based scheduling; hits are UI polling, update checks and request replay only
Finding: Bounded inspection found no user-facing schedules, event triggers, recurring tasks or completion-driven runs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/pr/pr.ts
Locator: pushAndPreview plus reviewActions (ready/merge/reopen/delete-branch) via gh; no forge comment ingestion in pr/github modules
Finding: PR open/update/ready/merge/reopen/delete-branch through gh with checks display. Forge review-comment ingestion not found.
Retrieved: 2026-11-12

## thinkrail:PLAN-02

Finding: Shared TODO plans carry the work with per-step review and independent reviewers, editable by user and agent, with implementation links through per-step commits and turn receipts. Plans survive restarts and mid-run steering. Completed steps form immutable history; explicit acceptance-criteria fields and a separate plan-edit history are undescribed.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Acceptance criteria live in plan steps, not a dedicated object; plan-edit history beyond step commits is undescribed.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/
Locator: Every turn gets a receipt; MCP servers, finally
Finding: Turn receipts (files changed plus Review turn button) and a stacked Changes tab with per-hunk Keep, Revert and Ask agent plus Next-unreviewed (J). MCP runs on pi’s built-in engine with presets (Context7, DeepWiki, Linear read-only, Sentry, Playwright); secrets must be ${VAR} or !command and repo .pi/mcp.json entries need per-entry approval; data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/todos/todos.ts
Locator: done steps immutable history; per-step commits; revision shas; TodoReviewInfo states
Finding: Completed plan steps are immutable history with per-step commits and revision shas; steps carry review states.
Retrieved: 2026-11-12

## thinkrail:PLAN-03

Finding: The pinned release implements a flat workspace model (own branch/cwd, settled/active states) with side workspaces and handoff growth, but no epics, parent/child depth, blockers, readiness gates, dependency enforcement or state propagation. A bundled workflow skill set routes by default without a mandatory gate.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

No hierarchy, dependency or enforcement constructs exist; only the workflow routing default was found.

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/workspaces/workspaces.ts
Locator: status available/detached; settledOverride settled/active; Default kind non-settleable; external attach
Finding: Flat workspace model with available/detached status and settled/active lifecycle. No epics, labels, priorities, queues, blockers, readiness gates or dependencies in code.
Retrieved: 2026-11-12

## thinkrail:PLAN-04

Finding: Project knowledge persists in the mtime-guarded SPEC.md graph the agent searches and maintains, plus pi skills, project skills and session state shared between CLI and app. Per-project trust grants scope what loads. Provenance, correction and freshness beyond index revalidation are only partly established.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Provenance is trust scoping, correction is file edits plus reload; deeper memory controls are undescribed.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-pi-skills-and-desktop-apps/
Locator: Pi compatibility; The Skills window; Desktop apps
Finding: ThinkRail embeds its own pi coding agent as a library running inside ThinkRail’s own process and shares pi’s ~/.pi folder, so CLI and app sessions keep history both ways. Skills and extensions from pi, Claude, Codex, Copilot and Gemini project folders are reused with per-chat switches. Desktop apps packaged with Electrobun run identically to the CLI browser host.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/agent/skillAdmission.ts
Locator: trusted / piResourceTrust per project; untrusted default
Finding: Project resources load only after per-project trust grants (trusted, piResourceTrust); untrusted is the default.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/spec-graph/tools/index.ts
Locator: create/delete/get/update/validate/grep tools; statuses draft/active/stale/done/deprecated; core/store.ts mtime revalidation
Finding: Spec CRUD plus validate and grep tools; the index revalidates by mtime/size and never serves stale. No approval, citation or conflict-detection tools.
Retrieved: 2026-11-12

## thinkrail:PLAN-05

Finding: The agent retrieves code and specs through pi tools, spec_search and a ranked spec index that also powers palette # search; file text search, web research and MCP knowledge presets extend it. Voice dictation and @ files add input modalities. Retrieval freshness and scope are partly established; citations, conflict detection and review-time rule enforcement are not.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Freshness and scope are partly established; no citation, conflict-detection or rule-enforcement mechanism exists.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/
Locator: Every turn gets a receipt; MCP servers, finally
Finding: Turn receipts (files changed plus Review turn button) and a stacked Changes tab with per-hunk Keep, Revert and Ask agent plus Next-unreviewed (J). MCP runs on pi’s built-in engine with presets (Context7, DeepWiki, Linear read-only, Sentry, Playwright); secrets must be ${VAR} or !command and repo .pi/mcp.json entries need per-entry approval; data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/the-chat/
Locator: Message batching; Code highlighting
Finding: Chat groups pi messages into styled batches with folded thinking and tool use, renders Markdown with Mermaid diagrams, highlights 36 languages with Shiki, and opens read-only code and diff tabs from Files. The composer references @ files.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/spec-graph/tools/index.ts
Locator: create/delete/get/update/validate/grep tools; statuses draft/active/stale/done/deprecated; core/store.ts mtime revalidation
Finding: Spec CRUD plus validate and grep tools; the index revalidates by mtime/size and never serves stale. No approval, citation or conflict-detection tools.
Retrieved: 2026-11-12

## thinkrail:PLAN-06

Finding: ThinkRail manages work as projects, workspaces (active to Settled shelf) and shared TODO plans rather than a labelled tracker: creation, edit, discussion, search, archive/Trash, reopen, dispatch-by-handoff and durable states exist and were confirmed in code, but prioritisation, labels, assignment and filters do not. No external tracker is required for core work.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

No labelled, prioritised or assigned issue model exists in docs or code; work tracking is workspaces plus TODO plans.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-1-release/
Locator: One box; Your own model server; pi packages; closing channels
Finding: Command palette finds chats, workspaces, commands and settings. Custom OpenAI chat-completions servers (Ollama, LM Studio, vLLM, llama.cpp presets) are saved into pi models.json. pi packages install from Settings for the user or a repository. Post notes ThinkRail is backed by JetBrains and links X (@ThinkRailAI), YouTube, TikTok, Discord and the GitHub repository.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/
Locator: Every turn gets a receipt; MCP servers, finally
Finding: Turn receipts (files changed plus Review turn button) and a stacked Changes tab with per-hunk Keep, Revert and Ask agent plus Next-unreviewed (J). MCP runs on pi’s built-in engine with presets (Context7, DeepWiki, Linear read-only, Sentry, Playwright); secrets must be ${VAR} or !command and repo .pi/mcp.json entries need per-entry approval; data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/workspaces/workspaces.ts
Locator: status available/detached; settledOverride settled/active; Default kind non-settleable; external attach
Finding: Flat workspace model with available/detached status and settled/active lifecycle. No epics, labels, priorities, queues, blockers, readiness gates or dependencies in code.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/todos/todos.ts
Locator: done steps immutable history; per-step commits; revision shas; TodoReviewInfo states
Finding: Completed plan steps are immutable history with per-step commits and revision shas; steps carry review states.
Retrieved: 2026-11-12

## thinkrail:PLAN-07

Finding: The agent works the same workspaces, chats and PRs the human sees: it starts side workspaces with chats, checks their chats, PRs and diffs, delegates to subagents and reports results, all visible in the Resources view. Reads, creates and result reporting are established in docs and tool code. Claims, assignment, state changes, dependencies, issue children, attribution and conflict handling do not exist.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Agent issue operations are limited to the documented tool set; tracker-style claim/assign/state/dependency operations do not exist.

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/
Locator: Every turn gets a receipt; MCP servers, finally
Finding: Turn receipts (files changed plus Review turn button) and a stacked Changes tab with per-hunk Keep, Revert and Ask agent plus Next-unreviewed (J). MCP runs on pi’s built-in engine with presets (Context7, DeepWiki, Linear read-only, Sentry, Playwright); secrets must be ${VAR} or !command and repo .pi/mcp.json entries need per-entry approval; data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/pi-subagents/src/extension.ts
Locator: Agent tool (model/thinking choice, run_in_background, subagents cannot call MCP tools); get_subagent_result status/report reads
Finding: Delegation tools are product-bundled: Agent with per-call model and thinking choice plus background runs, and get_subagent_result for status and finished reports. Subagents cannot call MCP tools.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/pi-background-commands/src/extension.ts
Locator: background_command start/list/output/stop; at most 8 active; latest 20 finished retained; stop cancels without waking parent
Finding: Background commands are session-owned with start, list, output and stop; at most 8 active with the latest 20 finished records retained.
Retrieved: 2026-11-12

## thinkrail:PLAN-08

Finding: SPEC.md files form a versioned, human- and agent-editable requirement graph beside the code with frontmatter parent links, maintained by spec_* tools and retrieved in later work through agent search and palette # search. Approval rules, automated drift checks and review-time spec gates do not exist.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Approval rules and review-time spec gates do not exist; drift control is convention plus a validate tool.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/todos/reviews.ts
Locator: independent reviewer flow; reviewLock; reviewerRole (see also host/planReviewQueue.ts)
Finding: Per-step independent review with locks and reviewer roles. No spec-conformance checks at review.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/spec-graph/tools/index.ts
Locator: create/delete/get/update/validate/grep tools; statuses draft/active/stale/done/deprecated; core/store.ts mtime revalidation
Finding: Spec CRUD plus validate and grep tools; the index revalidates by mtime/size and never serves stale. No approval, citation or conflict-detection tools.
Retrieved: 2026-11-12

## thinkrail:COORD-01

Finding: Several sessions run concurrently per workspace and several workspaces run in parallel, each isolated on its own branch and cwd — implemented in the session manager with parallel Agent calls and background commands. The Projects rail and Resources views show running work. No quotas exist.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

No concurrency quotas exist in docs or code.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/pi-subagents/src/extension.ts
Locator: Agent tool (model/thinking choice, run_in_background, subagents cannot call MCP tools); get_subagent_result status/report reads
Finding: Delegation tools are product-bundled: Agent with per-call model and thinking choice plus background runs, and get_subagent_result for status and finished reports. Subagents cannot call MCP tools.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/pi-background-commands/src/extension.ts
Locator: background_command start/list/output/stop; at most 8 active; latest 20 finished retained; stop cancels without waking parent
Finding: Background commands are session-owned with start, list, output and stop; at most 8 active with the latest 20 finished records retained.
Retrieved: 2026-11-12

## thinkrail:COORD-02

Finding: Dispatch is user-initiated: people create workspace chats and agents delegate to subagents; worktree isolation prevents file collision. No queues, claims, routing, duplicate prevention or enforced ownership exist in docs or code.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

No queue, claim, routing, duplicate-prevention or ownership-enforcement construct exists.

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/workspaces/workspaces.ts
Locator: status available/detached; settledOverride settled/active; Default kind non-settleable; external attach
Finding: Flat workspace model with available/detached status and settled/active lifecycle. No epics, labels, priorities, queues, blockers, readiness gates or dependencies in code.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/auth
Locator: Searched auth, contracts and web store for sso|organization|invite|member-role models; auth is Tailscale ACLs plus an owner field
Finding: No user, organisation, role, SSO, membership or provisioning model in code. Single-owner external auth.
Retrieved: 2026-11-12

## thinkrail:COORD-03

Finding: ThinkRail-bundled pi-subagents and pi-delegation give every parent session Agent and get_subagent_result tools over isolated child sessions, with per-session model and effort choice, live progress and retained outcomes in Resources. Delegation is pi-only with no cross-harness teams; child messaging detail and auth are undescribed, and follow-up is re-reading, not reopening.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Delegation is pi-only with no cross-harness teams; messaging detail, auth and reopening are undescribed or absent.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/pi-subagents/src/extension.ts
Locator: Agent tool (model/thinking choice, run_in_background, subagents cannot call MCP tools); get_subagent_result status/report reads
Finding: Delegation tools are product-bundled: Agent with per-call model and thinking choice plus background runs, and get_subagent_result for status and finished reports. Subagents cannot call MCP tools.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/auth
Locator: Searched auth, contracts and web store for sso|organization|invite|member-role models; auth is Tailscale ACLs plus an owner field
Finding: No user, organisation, role, SSO, membership or provisioning model in code. Single-owner external auth.
Retrieved: 2026-11-12

## thinkrail:COORD-04

Finding: Unattended triggers do not exist: bounded v0.3.2 inspection of packages/server, apps/* and packages/* for schedul|cron|trigger|recur|setInterval-based scheduling found only UI polling, update checks and request replay. No schedules, event triggers, recurring tasks or completion-driven runs exist.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

No scheduler, trigger, recurrence or completion-condition mechanism exists in the pinned release.

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src
Locator: Searched packages/server, apps/* and packages/* at v0.3.2 for schedul|cron|trigger|recur|setInterval-based scheduling; hits are UI polling, update checks and request replay only
Finding: Bounded inspection found no user-facing schedules, event triggers, recurring tasks or completion-driven runs.
Retrieved: 2026-11-12

## thinkrail:COORD-05

Finding: Running turns accept steering and queued follow-ups; background commands and subagents can be watched, inspected and stopped from Resources. MCP data-changing calls and structured agent questions surface as pending decisions with allow/deny control, and history persists. Pause, resume, escalation and terminal-side intervention do not exist; errors surface as toasts.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

No pause, resume, escalation or terminal-side intervention exists.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-1-release/
Locator: One box; Your own model server; pi packages; closing channels
Finding: Command palette finds chats, workspaces, commands and settings. Custom OpenAI chat-completions servers (Ollama, LM Studio, vLLM, llama.cpp presets) are saved into pi models.json. pi packages install from Settings for the user or a repository. Post notes ThinkRail is backed by JetBrains and links X (@ThinkRailAI), YouTube, TikTok, Discord and the GitHub repository.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/
Locator: Every turn gets a receipt; MCP servers, finally
Finding: Turn receipts (files changed plus Review turn button) and a stacked Changes tab with per-hunk Keep, Revert and Ask agent plus Next-unreviewed (J). MCP runs on pi’s built-in engine with presets (Context7, DeepWiki, Linear read-only, Sentry, Playwright); secrets must be ${VAR} or !command and repo .pi/mcp.json entries need per-entry approval; data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/agent/mcp/sessionHost.ts
Locator: MCP_CONFIRM_ALWAYS; confirm() on data-changing calls with no-UI-attached fallback; allow once/chat/always
Finding: MCP confirmation is product code: data-changing calls confirm with Deny, Allow once, Allow in this chat or Always allow, and fail closed with no UI attached.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/apps/web/src/chat/ChatTranscript.tsx
Locator: toast.error on locate and resolve failures
Finding: User-facing error toasts exist; silent waits and escalation paths do not.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/terminal
Locator: Searched terminal code for approv|confirm|permission: none; completionQueue resume is output resumption
Finding: No approval or intervention model in terminal code.
Retrieved: 2026-11-12

## thinkrail:COORD-06

Finding: The Projects panel lists workspaces across projects with settled states, attention markers and per-branch PR status; no parent/child, dependency or workload views exist and no fleet fixture was exercised. Navigation errors cannot be determined without running the product.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

No parent/child, dependency or workload views exist; no fleet fixture was exercised. Navigation errors need interaction and stay unknown.

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-1-release/
Locator: One box; Your own model server; pi packages; closing channels
Finding: Command palette finds chats, workspaces, commands and settings. Custom OpenAI chat-completions servers (Ollama, LM Studio, vLLM, llama.cpp presets) are saved into pi models.json. pi packages install from Settings for the user or a repository. Post notes ThinkRail is backed by JetBrains and links X (@ThinkRailAI), YouTube, TikTok, Discord and the GitHub repository.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/workspaces/workspaces.ts
Locator: status available/detached; settledOverride settled/active; Default kind non-settleable; external attach
Finding: Flat workspace model with available/detached status and settled/active lifecycle. No epics, labels, priorities, queues, blockers, readiness gates or dependencies in code.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/apps/web/src/notifications/attentionNotificationEngine.ts
Locator: rising-edge attention gate per session; desktopNotifications; unread holds
Finding: Attention engine with per-session unread holds plus desktop notifications.
Retrieved: 2026-11-12

## thinkrail:COORD-07

Finding: Quick scratch chats grow into workspace work via Continue-in-workspace handoff, and plain-language side-workspace requests configure delegation; per-session model and effort plus mid-run steering adapt execution live. Bundled workflow skills exist without a mandatory preset gate. Roles during work and retained relationships are only partly described.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Only the cited atomic findings are established. Live role labelling, retained relationship views and coordinator docs are only partly described.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

## thinkrail:RUN-01

Finding: Execution is local: the desktop app and the CLI host run the in-process pi engine on the user’s own machine, provisioned by the installer, with no vendor cloud, no user-server path and no resource, region or expiry concepts. State rebuilds on other surfaces over the wire, but execution does not survive the originating host.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Local-only execution with no remote, hosted or laptop-independent operation; state follows surfaces, execution does not.

Source: https://thinkrail.ai/blog/thinkrail-pi-skills-and-desktop-apps/
Locator: Pi compatibility; The Skills window; Desktop apps
Finding: ThinkRail embeds its own pi coding agent as a library running inside ThinkRail’s own process and shares pi’s ~/.pi folder, so CLI and app sessions keep history both ways. Skills and extensions from pi, Claude, Codex, Copilot and Gemini project folders are reused with per-chat switches. Desktop apps packaged with Electrobun run identically to the CLI browser host.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/workspaces/workspaces.ts
Locator: status available/detached; settledOverride settled/active; Default kind non-settleable; external attach
Finding: Flat workspace model with available/detached status and settled/active lifecycle. No epics, labels, priorities, queues, blockers, readiness gates or dependencies in code.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/contracts/src/wsProtocol.ts
Locator: session.list / session.getMessages / session.created; host requestReplayCache repairs missed deltas
Finding: Hydrate-then-stream: clients rebuild projects, workspaces, sessions and transcripts on reload, second tab, phone or host restart; reconnect repairs missed deltas.
Retrieved: 2026-11-12

## thinkrail:RUN-02

Finding: Isolation is git worktrees: separate directories, branches and cwds per workspace on the same machine and OS user, with env-based secret handling. No container, VM, OS-sandbox, process or network boundary exists; pi runs in-process. A worktree is file separation, not a security boundary.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

File separation only: same machine, user and process; no security boundary is claimed.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/introducing-thinkrail/
Locator: Install; What is next
Finding: ThinkRail is an agentic IDE for the Pi coding agent that complements its CLI. Desktop installers for macOS, Windows x64 and Linux x64/ARM64, or a CLI host that opens a browser tab. Every working session operates on a separate git branch merged only after review; LLM providers are configured in Settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/
Locator: Every turn gets a receipt; MCP servers, finally
Finding: Turn receipts (files changed plus Review turn button) and a stacked Changes tab with per-hunk Keep, Revert and Ask agent plus Next-unreviewed (J). MCP runs on pi’s built-in engine with presets (Context7, DeepWiki, Linear read-only, Sentry, Playwright); secrets must be ${VAR} or !command and repo .pi/mcp.json entries need per-entry approval; data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/host/server.ts
Locator: fetch handler: /ws, /health, static and file/font routes only; no REST router
Finding: The host exposes only the internal /ws wire, /health and static/file routes. No public REST API, SDK surface, MCP server transport or webhooks exist in code.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/workspaces/workspaces.ts
Locator: status available/detached; settledOverride settled/active; Default kind non-settleable; external attach
Finding: Flat workspace model with available/detached status and settled/active lifecycle. No epics, labels, priorities, queues, blockers, readiness gates or dependencies in code.
Retrieved: 2026-11-12

## thinkrail:RUN-03

Finding: State reconstructs from host reads on reload, second tab, phone or host restart, with request replay and delta repair on reconnect; transcripts persist on disk. Disconnect, crash and multi-day behaviour on one machine are partly established. Expiry, duplicates handling and repair flows do not exist.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Continuity is same-machine persistence plus state rebuild; crash recovery, duplicates and repair are undescribed or absent.

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/workspaces/workspaces.ts
Locator: status available/detached; settledOverride settled/active; Default kind non-settleable; external attach
Finding: Flat workspace model with available/detached status and settled/active lifecycle. No epics, labels, priorities, queues, blockers, readiness gates or dependencies in code.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/contracts/src/wsProtocol.ts
Locator: session.list / session.getMessages / session.created; host requestReplayCache repairs missed deltas
Finding: Hydrate-then-stream: clients rebuild projects, workspaces, sessions and transcripts on reload, second tab, phone or host restart; reconnect repairs missed deltas.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src
Locator: Searched packages/server, apps/* and packages/* at v0.3.2 for schedul|cron|trigger|recur|setInterval-based scheduling; hits are UI polling, update checks and request replay only
Finding: Bounded inspection found no user-facing schedules, event triggers, recurring tasks or completion-driven runs.
Retrieved: 2026-11-12

## thinkrail:RUN-04

Finding: The only environment mechanism is per-host environment-variable injection for agents, terminals and MCP servers. Dependency setup, caches, snapshots, services, ports, duplication, collisions, remote setup and automatic repair do not exist in the product.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Environment support is env injection only; all other reliability mechanisms are absent.

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

## thinkrail:RUN-05

Finding: Limits and failure handling do not exist: bounded v0.3.2 inspection of the server found only model maxTokens passthrough and an internal session-shutdown budget. No time, turn, token or spend limits, timeouts, retries or provider-failure budgets exist. Token and cost displays are visibility, not enforcement.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

No limits, timeouts, retries or failure budgets exist in the pinned release.

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/agent
Locator: Searched server code for spend/budget/token-limit/rate-limit/throttle enforcement; only model maxTokens passthrough and a shutdown budget
Finding: No user-facing time, turn, token or spend limits, retries or failure budgets in code.
Retrieved: 2026-11-12

## thinkrail:RUN-06

Finding: Turn receipts, folded tool steps, command log tails, per-chat token and cost ticks, MCP pending-confirm cards and topbar PR checks and review decisions give live status; per-chat token stats are the only statistics, and reconnects repair state. Usage export and measured responsiveness do not exist.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Statistics stop at per-chat tokens and cost; no export, aggregates or measured timings exist.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-1-release/
Locator: One box; Your own model server; pi packages; closing channels
Finding: Command palette finds chats, workspaces, commands and settings. Custom OpenAI chat-completions servers (Ollama, LM Studio, vLLM, llama.cpp presets) are saved into pi models.json. pi packages install from Settings for the user or a repository. Post notes ThinkRail is backed by JetBrains and links X (@ThinkRailAI), YouTube, TikTok, Discord and the GitHub repository.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/
Locator: Every turn gets a receipt; MCP servers, finally
Finding: Turn receipts (files changed plus Review turn button) and a stacked Changes tab with per-hunk Keep, Revert and Ask agent plus Next-unreviewed (J). MCP runs on pi’s built-in engine with presets (Context7, DeepWiki, Linear read-only, Sentry, Playwright); secrets must be ${VAR} or !command and repo .pi/mcp.json entries need per-entry approval; data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/the-chat/
Locator: Message batching; Code highlighting
Finding: Chat groups pi messages into styled batches with folded thinking and tool use, renders Markdown with Mermaid diagrams, highlights 36 languages with Shiki, and opens read-only code and diff tabs from Files. The composer references @ files.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/contracts/src/wsProtocol.ts
Locator: session.list / session.getMessages / session.created; host requestReplayCache repairs missed deltas
Finding: Hydrate-then-stream: clients rebuild projects, workspaces, sessions and transcripts on reload, second tab, phone or host restart; reconnect repairs missed deltas.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src
Locator: Searched server and web code for exportHistory/exportChat/backup/usage-export; only CSV file renderers and package-registry links
Finding: No history, usage or task export in code.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/apps/web/src
Locator: Searched app and server code for timing, metrics, perf-hook or review-measurement instrumentation: only product analytics events
Finding: No interaction-timing, review-effort or measurement instrumentation in code; shown figures are single documented cases and analytics.
Retrieved: 2026-11-12

## thinkrail:RUN-07

Finding: Every chat ticks pi-reported tokens (input, output, cache reads and writes) and cost live; JetBrains AI quota snapshots on a 30-second default cadence with a 20-second PR-check refresh. Child, epic and aggregate costs, reconciliation, alerts, export and drill-down do not exist, and unknown subscription marginal cost is never rendered as zero.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Cost visibility is per-chat tokens plus quota snapshots only; no aggregation, reconciliation, alerts or export exists.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/central-integration.md
Locator: The chain; Quota chain
Finding: JetBrains AI models reach ThinkRail through the user-owned central CLI with a recurring AI-credit quota; sign-in, status and quota orchestration span the provider card and shell, with quota snapshots on a 1–3600 second cadence (30 seconds by default).
Retrieved: 2026-11-12

## thinkrail:RUN-08

Finding: Parallel sessions and workspaces run with no declared concurrency limits, queues or resource awareness; the only controls are session ownership and stopping background commands or subagents. No bounded load behaviour was established in code.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

No limits, queues, resource awareness or bounded testing exist.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/pi-subagents/src/extension.ts
Locator: Agent tool (model/thinking choice, run_in_background, subagents cannot call MCP tools); get_subagent_result status/report reads
Finding: Delegation tools are product-bundled: Agent with per-call model and thinking choice plus background runs, and get_subagent_result for status and finished reports. Subagents cannot call MCP tools.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/pi-background-commands/src/extension.ts
Locator: background_command start/list/output/stop; at most 8 active; latest 20 finished retained; stop cancels without waking parent
Finding: Background commands are session-owned with start, list, output and stop; at most 8 active with the latest 20 finished records retained.
Retrieved: 2026-11-12

## thinkrail:TEAM-01

Finding: Live human collaboration does not exist: ThinkRail is a single-owner local product whose auth model (Tailscale ACLs plus an owner field, no login UI) has no second user, shared prompting, presence, ordering, attribution or permission constructs. The launch post’s Git-and-GitHub line does not establish co-steering.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Single-owner product: no multi-user construct exists in docs or code.

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/auth
Locator: Searched auth, contracts and web store for sso|organization|invite|member-role models; auth is Tailscale ACLs plus an owner field
Finding: No user, organisation, role, SSO, membership or provisioning model in code. Single-owner external auth.
Retrieved: 2026-11-12

## thinkrail:TEAM-02

Finding: Roles and access boundaries do not exist: no organisations, project or task roles, membership, SSO, provisioning, revocation or plan scoping, because there are no accounts. Host reach is a network (Tailscale) matter, and SSO is excluded by the no-login-UI non-goal.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

No role, membership, SSO or provisioning construct exists.

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/auth
Locator: Searched auth, contracts and web store for sso|organization|invite|member-role models; auth is Tailscale ACLs plus an owner field
Finding: No user, organisation, role, SSO, membership or provisioning model in code. Single-owner external auth.
Retrieved: 2026-11-12

## thinkrail:TEAM-03

Finding: MCP data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow (per project, lapsing on entry change); repo resources and repo MCP entries stay off until explicit grants; shell-credential hygiene is host-enforced. The human user approves merges. Shell-command and network approvals are not a product surface, and no tunnels exist.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

No product-owned shell or network approval and no tunnels exist; MCP, trust-grant and delivery approvals do.

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-1-release/
Locator: One box; Your own model server; pi packages; closing channels
Finding: Command palette finds chats, workspaces, commands and settings. Custom OpenAI chat-completions servers (Ollama, LM Studio, vLLM, llama.cpp presets) are saved into pi models.json. pi packages install from Settings for the user or a repository. Post notes ThinkRail is backed by JetBrains and links X (@ThinkRailAI), YouTube, TikTok, Discord and the GitHub repository.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-pi-skills-and-desktop-apps/
Locator: Pi compatibility; The Skills window; Desktop apps
Finding: ThinkRail embeds its own pi coding agent as a library running inside ThinkRail’s own process and shares pi’s ~/.pi folder, so CLI and app sessions keep history both ways. Skills and extensions from pi, Claude, Codex, Copilot and Gemini project folders are reused with per-chat switches. Desktop apps packaged with Electrobun run identically to the CLI browser host.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/
Locator: Every turn gets a receipt; MCP servers, finally
Finding: Turn receipts (files changed plus Review turn button) and a stacked Changes tab with per-hunk Keep, Revert and Ask agent plus Next-unreviewed (J). MCP runs on pi’s built-in engine with presets (Context7, DeepWiki, Linear read-only, Sentry, Playwright); secrets must be ${VAR} or !command and repo .pi/mcp.json entries need per-entry approval; data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/host/server.ts
Locator: fetch handler: /ws, /health, static and file/font routes only; no REST router
Finding: The host exposes only the internal /ws wire, /health and static/file routes. No public REST API, SDK surface, MCP server transport or webhooks exist in code.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/terminal
Locator: Searched terminal code for approv|confirm|permission: none; completionQueue resume is output resumption
Finding: No approval or intervention model in terminal code.
Retrieved: 2026-11-12

## thinkrail:TEAM-04

Finding: Turn receipts, resource history, anchored review comments and PR states persist across sessions and host restarts; Settled workspaces and Trash give retention shape. History alteration is delete-only, export and integrity models do not exist, and no audit claim is made.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Retention shape only; no export or integrity model exists and no audit claim is made.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/
Locator: Every turn gets a receipt; MCP servers, finally
Finding: Turn receipts (files changed plus Review turn button) and a stacked Changes tab with per-hunk Keep, Revert and Ask agent plus Next-unreviewed (J). MCP runs on pi’s built-in engine with presets (Context7, DeepWiki, Linear read-only, Sentry, Playwright); secrets must be ${VAR} or !command and repo .pi/mcp.json entries need per-entry approval; data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/auth
Locator: Searched auth, contracts and web store for sso|organization|invite|member-role models; auth is Tailscale ACLs plus an owner field
Finding: No user, organisation, role, SSO, membership or provisioning model in code. Single-owner external auth.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src
Locator: Searched server and web code for exportHistory/exportChat/backup/usage-export; only CSV file renderers and package-registry links
Finding: No history, usage or task export in code.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src
Locator: Searched server for audit, integrity or retention-model code: history is append/delete only
Finding: No audit, retention or integrity model in code.
Retrieved: 2026-11-12

## thinkrail:TEAM-05

Finding: Review is a guided loop: the palette and Review-turn button surface pending work, stacked Changes tabs with Keep/Revert/Ask-agent plus Next-unreviewed (J key in code) navigate evidence, anchored comments and Fix-with-agent request changes, and the topbar names the next shipping step. Phone viewports adapt; effort timing, missed-evidence analysis and switching costs are not measured.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Review effort, missed evidence and switching costs are not measured. Bulk and cross-branch review queues are judged in SHIP-06.

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-1-release/
Locator: One box; Your own model server; pi packages; closing channels
Finding: Command palette finds chats, workspaces, commands and settings. Custom OpenAI chat-completions servers (Ollama, LM Studio, vLLM, llama.cpp presets) are saved into pi models.json. pi packages install from Settings for the user or a repository. Post notes ThinkRail is backed by JetBrains and links X (@ThinkRailAI), YouTube, TikTok, Discord and the GitHub repository.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/
Locator: Every turn gets a receipt; MCP servers, finally
Finding: Turn receipts (files changed plus Review turn button) and a stacked Changes tab with per-hunk Keep, Revert and Ask agent plus Next-unreviewed (J). MCP runs on pi’s built-in engine with presets (Context7, DeepWiki, Linear read-only, Sentry, Playwright); secrets must be ${VAR} or !command and repo .pi/mcp.json entries need per-entry approval; data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/apps/web/src/lib/viewport.ts
Locator: PHONE_QUERIES pointer:coarse and max-width:767px; usePhoneViewport hook
Finding: Phone-viewport detection adapts the UI below 767px width.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/apps/web/src/panels/ChangesReviewPane.tsx
Locator: NEXT_UNREVIEWED_KEY j; hotkey handling in Composer, HistoryOverlay and review panes
Finding: Keyboard operation including J for next-unreviewed plus palette and file-search shortcuts.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/apps/web/src
Locator: Searched app and server code for timing, metrics, perf-hook or review-measurement instrumentation: only product analytics events
Finding: No interaction-timing, review-effort or measurement instrumentation in code; shown figures are single documented cases and analytics.
Retrieved: 2026-11-12

## thinkrail:TEAM-06

Finding: Same-user continuity is implemented: previous conversations reopen with history and sessions move between the pi CLI and the app. Second-person takeover, ownership transfer, permissions, runtime handoff and context-loss handling do not exist in this single-owner product.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Same-user session continuity only; no second-person handoff exists to evaluate.

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-pi-skills-and-desktop-apps/
Locator: Pi compatibility; The Skills window; Desktop apps
Finding: ThinkRail embeds its own pi coding agent as a library running inside ThinkRail’s own process and shares pi’s ~/.pi folder, so CLI and app sessions keep history both ways. Skills and extensions from pi, Claude, Codex, Copilot and Gemini project folders are reused with per-chat switches. Desktop apps packaged with Electrobun run identically to the CLI browser host.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/auth
Locator: Searched auth, contracts and web store for sso|organization|invite|member-role models; auth is Tailscale ACLs plus an owner field
Finding: No user, organisation, role, SSO, membership or provisioning model in code. Single-owner external auth.
Retrieved: 2026-11-12

## thinkrail:SHIP-01

Finding: Diffs, documents, file previews, UI mockups, test outputs and reviewer outputs persist with the transcript and branch; per-run Changes tabs and per-hunk review carry the evidence. Screenshot capture, recordings, a cross-task gallery and prompt leakage into outputs do not exist in the pinned release.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

No screenshot/record capture, cross-task gallery or prompt leakage path exists.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/
Locator: Every turn gets a receipt; MCP servers, finally
Finding: Turn receipts (files changed plus Review turn button) and a stacked Changes tab with per-hunk Keep, Revert and Ask agent plus Next-unreviewed (J). MCP runs on pi’s built-in engine with presets (Context7, DeepWiki, Linear read-only, Sentry, Playwright); secrets must be ${VAR} or !command and repo .pi/mcp.json entries need per-entry approval; data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/apps/web/src
Locator: Searched app, server and CLI for screenshot/captureScreen/gallery capture; GalleryLink points at the pi package registry
Finding: No artifact gallery, screenshot or recording capture in code.
Retrieved: 2026-11-12

## thinkrail:SHIP-02

Finding: Verification is agent-driven and displayed, not product-enforced: the agent runs tests in terminals, CI checks display on the PR, and plan steps can route to an independent reviewer. Required gates, lint/type gates, failure blocking, requirement-conflict handling and configured or enforced policy do not exist.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

ThinkRail configures and enforces no verification gates of its own.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/
Locator: Every turn gets a receipt; MCP servers, finally
Finding: Turn receipts (files changed plus Review turn button) and a stacked Changes tab with per-hunk Keep, Revert and Ask agent plus Next-unreviewed (J). MCP runs on pi’s built-in engine with presets (Context7, DeepWiki, Linear read-only, Sentry, Playwright); secrets must be ${VAR} or !command and repo .pi/mcp.json entries need per-entry approval; data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/spec-graph/tools/index.ts
Locator: create/delete/get/update/validate/grep tools; statuses draft/active/stale/done/deprecated; core/store.ts mtime revalidation
Finding: Spec CRUD plus validate and grep tools; the index revalidates by mtime/size and never serves stale. No approval, citation or conflict-detection tools.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src
Locator: Searched todos/reviews/pr for required/enforced verification gates; CI is displayed, review is optional, nothing blocks
Finding: No required or enforced verification gates in code.
Retrieved: 2026-11-12

## thinkrail:SHIP-03

Finding: The full GitHub loop is integrated in the topbar: own branches and worktrees, per-step commits, PR open/update through gh with templates or agent drafts, CI response with Fix-with-agent, rebase preview, and merge/reopen/branch-delete actions — all present in the pinned pr/github modules. PR-comment round-trips and GitLab review actions are the limits.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

GitLab is limited to a prefilled MR page; forge PR-comment round-trips are undescribed in code.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/pr/pr.ts
Locator: pushAndPreview plus reviewActions (ready/merge/reopen/delete-branch) via gh; no forge comment ingestion in pr/github modules
Finding: PR open/update/ready/merge/reopen/delete-branch through gh with checks display. Forge review-comment ingestion not found.
Retrieved: 2026-11-12

## thinkrail:SHIP-04

Finding: The human user approves (Ready for review), merges (repo-allowed methods, remembered per project), reopens and deletes remote branches from the topbar, governed by GitHub merge state. Release and deploy authority do not exist in the product.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Release and deployment authority do not exist in the product.

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/apps/cli/src/args.ts
Locator: USAGE string; exhaustive parseArgs (unknown options throw); SUBCOMMANDS update/uninstall
Finding: Complete CLI inventory: launch flags plus update and uninstall subcommands only. No session, task, steering or review operations exist in the launcher.
Retrieved: 2026-11-12

## thinkrail:SHIP-05

Finding: Turn receipts and per-step commits link work to code, the topbar links branches to PRs with delivery state and retained transcripts, and local revert (hunk/file Keep/Revert) plus stale-approval invalidation (Keep lapses on re-edit) are built in. Build/deployment links and post-merge rollback do not exist.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Build and deployment links plus post-merge rollback do not exist.

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/
Locator: Every turn gets a receipt; MCP servers, finally
Finding: Turn receipts (files changed plus Review turn button) and a stacked Changes tab with per-hunk Keep, Revert and Ask agent plus Next-unreviewed (J). MCP runs on pi’s built-in engine with presets (Context7, DeepWiki, Linear read-only, Sentry, Playwright); secrets must be ${VAR} or !command and repo .pi/mcp.json entries need per-entry approval; data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/pr/pr.ts
Locator: pushAndPreview plus reviewActions (ready/merge/reopen/delete-branch) via gh; no forge comment ingestion in pr/github modules
Finding: PR open/update/ready/merge/reopen/delete-branch through gh with checks display. Forge review-comment ingestion not found.
Retrieved: 2026-11-12

## thinkrail:SHIP-06

Finding: Per-branch review is implemented (receipts, retained findings, anchored change requests, next-step topbar, stale-Keep invalidation), and the Projects/Settled views list reviewable work — but grouping, risk filters, exact-revision batch approval, dependency queues and check dedup do not exist. No batch queue exists.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Per-branch review only, not a coordinated batch review-and-delivery queue.

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-1-release/
Locator: One box; Your own model server; pi packages; closing channels
Finding: Command palette finds chats, workspaces, commands and settings. Custom OpenAI chat-completions servers (Ollama, LM Studio, vLLM, llama.cpp presets) are saved into pi models.json. pi packages install from Settings for the user or a repository. Post notes ThinkRail is backed by JetBrains and links X (@ThinkRailAI), YouTube, TikTok, Discord and the GitHub repository.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-2-0-review-the-turn/
Locator: Every turn gets a receipt; MCP servers, finally
Finding: Turn receipts (files changed plus Review turn button) and a stacked Changes tab with per-hunk Keep, Revert and Ask agent plus Next-unreviewed (J). MCP runs on pi’s built-in engine with presets (Context7, DeepWiki, Linear read-only, Sentry, Playwright); secrets must be ${VAR} or !command and repo .pi/mcp.json entries need per-entry approval; data-changing calls confirm in the chat with Deny, Allow once, Allow in this chat or Always allow.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src
Locator: Searched host/todos for batch/dependency queues; planReviewQueue is per-step review, settledLifecycle is workspace states
Finding: No batch review or dependency-aware merge queues in code.
Retrieved: 2026-11-12

## thinkrail:OWN-01

Finding: ThinkRail is Apache-2.0 across the public repo: desktop app, CLI host, engine library, contracts, web UI and all bundled extensions ship from one codebase with no proprietary twin or licence exception. The revision is pinned to release v0.3.2 (commit 1bc1a9b).

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-05-11
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Single-repo finding: no component carries a different licence.

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/releases
Locator: Releases list; per-release version and date
Finding: Stable v0.3.2 published 2026-11-06; v0.4.0 stable published 2026-11-12 (latest at check time). Free desktop and CLI assets per platform with SHA256SUMS.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail
Locator: Repository header and metadata
Finding: Public repository in the JetBrains organisation, default branch main, pushed 2026-11-12. 8,189 stars, 518 forks and 257 open issues observed 2026-11-12. Licensed Apache-2.0; homepage thinkrail.ai.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/LICENSE
Locator: License grant
Finding: Repository licensed under the Apache License, Version 2.0.
Retrieved: 2026-11-12

## thinkrail:OWN-02

Finding: The core ADE runs entirely on user-controlled machines with no vendor services to keep: optional companions are the user’s git, gh, central CLI and Tailscale. Uninstall removes the binary and optionally ~/.thinkrail state. Task, context and history export formats do not exist.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-05-11
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Export formats and history portability do not exist.

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-pi-skills-and-desktop-apps/
Locator: Pi compatibility; The Skills window; Desktop apps
Finding: ThinkRail embeds its own pi coding agent as a library running inside ThinkRail’s own process and shares pi’s ~/.pi folder, so CLI and app sessions keep history both ways. Skills and extensions from pi, Claude, Codex, Copilot and Gemini project folders are reused with per-chat switches. Desktop apps packaged with Electrobun run identically to the CLI browser host.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src
Locator: Searched server and web code for exportHistory/exportChat/backup/usage-export; only CSV file renderers and package-registry links
Finding: No history, usage or task export in code.
Retrieved: 2026-11-12

## thinkrail:OWN-03

Finding: Code, prompts and credentials stay with the user: in-process pi sends them to the user’s own providers, never to ThinkRail servers. Telemetry is basic install-ID events plus always-on error reports via PostHog; extra sharing is opt-in at first run and in Settings Privacy (or --no-analytics). Retention beyond a 30-day link expiry, training use and residency are unstated business facts.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-03-12
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Retention timelines, training use and residency are unstated.

Source: https://thinkrail.ai/blog/thinkrail-0-3-1-release/
Locator: One box; Your own model server; pi packages; closing channels
Finding: Command palette finds chats, workspaces, commands and settings. Custom OpenAI chat-completions servers (Ollama, LM Studio, vLLM, llama.cpp presets) are saved into pi models.json. pi packages install from Settings for the user or a repository. Post notes ThinkRail is backed by JetBrains and links X (@ThinkRailAI), YouTube, TikTok, Discord and the GitHub repository.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src/auth
Locator: Searched auth, contracts and web store for sso|organization|invite|member-role models; auth is Tailscale ACLs plus an owner field
Finding: No user, organisation, role, SSO, membership or provisioning model in code. Single-owner external auth.
Retrieved: 2026-11-12

## thinkrail:OWN-04

Finding: ThinkRail itself is free: Apache-2.0 source, free downloads, no accounts, no paid plan and no metered units. Model and compute spend belongs to the user’s own providers and hardware and is never billed or marked up by ThinkRail. Billing dimensions do not apply to a product with no paid offering.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-01-11
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

No paid plans exist, so billing atoms are moot business facts; model and compute spend is the user’s own provider and hardware cost.

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/central-integration.md
Locator: The chain; Quota chain
Finding: JetBrains AI models reach ThinkRail through the user-owned central CLI with a recurring AI-credit quota; sign-in, status and quota orchestration span the provider card and shell, with quota snapshots on a 1–3600 second cadence (30 seconds by default).
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/releases
Locator: Releases list; per-release version and date
Finding: Stable v0.3.2 published 2026-11-06; v0.4.0 stable published 2026-11-12 (latest at check time). Free desktop and CLI assets per platform with SHA256SUMS.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/LICENSE
Locator: License grant
Finding: Repository licensed under the Apache License, Version 2.0.
Retrieved: 2026-11-12

## thinkrail:OWN-05

Finding: Fixed ThinkRail cost is $0 for one, two or five developers (free installs, parallel workspaces included, no seats). Variable cost is the team’s own provider spend on tokens; no invented per-task averages are used. Two-person collaboration is limited by the single-user design and shared via git.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-01-11
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Fixed $0 cost is established; variable provider spend cannot be fixed without usage assumptions, which are not invented.

Source: https://thinkrail.ai/
Locator: Hero and install matrix; Why ThinkRail; Features (workspaces, editor, agent-chat, specs); Open source section
Finding: Agentic IDE around the pi agent: git-worktree workspaces with own branch and cwd, Monaco editor tabs, terminals, diffs, concurrent chats with per-session model and live token/cost ticks, and a spec graph the agent reads. Desktop apps for macOS, Windows and Linux plus a thinkrail CLI that opens the same app in a browser. Open source Apache-2.0; a JetBrains InnovationHub project.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/central-integration.md
Locator: The chain; Quota chain
Finding: JetBrains AI models reach ThinkRail through the user-owned central CLI with a recurring AI-credit quota; sign-in, status and quota orchestration span the provider card and shell, with quota snapshots on a 1–3600 second cadence (30 seconds by default).
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/releases
Locator: Releases list; per-release version and date
Finding: Stable v0.3.2 published 2026-11-06; v0.4.0 stable published 2026-11-12 (latest at check time). Free desktop and CLI assets per platform with SHA256SUMS.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/LICENSE
Locator: License grant
Finding: Repository licensed under the Apache License, Version 2.0.
Retrieved: 2026-11-12

## thinkrail:OWN-06

Finding: Pre-1.0 beta under active development: stable v0.3.2 plus public nightlies with daily commits, free of access restrictions beyond provider credentials. Support is Discord plus GitHub issues with no committed response times and no published status history; uninstall documents exit without export.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-01-11
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Response commitments, status history and export options are unpublished or absent.

Source: https://thinkrail.ai/blog/thinkrail-0-3-0-whole-loop-one-window/
Locator: Ship the branch from the topbar; A first run that ends with a working model
Finding: Topbar Remote and Pull request segments drive publish, push, sync, open-PR and merge through the user-owned gh CLI, showing CI checks and review decision re-read every 20 seconds; merging locally and GitLab review actions are not yet available. First-run wizard detects signed-in Claude Code, Codex, Copilot, Kimi CLI or Grok Build configs and connects through pi auth without borrowing their credentials.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/thinkrail-0-3-1-release/
Locator: One box; Your own model server; pi packages; closing channels
Finding: Command palette finds chats, workspaces, commands and settings. Custom OpenAI chat-completions servers (Ollama, LM Studio, vLLM, llama.cpp presets) are saved into pi models.json. pi packages install from Settings for the user or a repository. Post notes ThinkRail is backed by JetBrains and links X (@ThinkRailAI), YouTube, TikTok, Discord and the GitHub repository.
Retrieved: 2026-11-12

Source: https://thinkrail.ai/blog/gui-overview/
Locator: The main GUI; The chat; The workspace; Settings
Finding: Fifteen numbered components: chat tabs with turn summaries and Review turn, read-only file and diff tabs, chat history popup, terminals, per-chat token usage, Resources popup (background commands, subagents, MCP servers), Skills popup, model picker, Projects/workspaces/Settled panel, Specs/Files/Changes/Review/TODO panels, command palette, and provider, MCP, prompt, Pi-config and chat-tuning settings.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/releases
Locator: Releases list; per-release version and date
Finding: Stable v0.3.2 published 2026-11-06; v0.4.0 stable published 2026-11-12 (latest at check time). Free desktop and CLI assets per platform with SHA256SUMS.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail
Locator: Repository header and metadata
Finding: Public repository in the JetBrains organisation, default branch main, pushed 2026-11-12. 8,189 stars, 518 forks and 257 open issues observed 2026-11-12. Licensed Apache-2.0; homepage thinkrail.ai.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/LICENSE
Locator: License grant
Finding: Repository licensed under the Apache License, Version 2.0.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/issues
Locator: Issues list (bugs and feature requests venue)
Finding: GitHub issues is the venue for bugs and feature requests, with Discord linked for discussion. No roadmap document, changelog file or milestones were found; release history is spread across the blog and releases.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/v0.3.2/packages/server/src
Locator: Searched server and web code for exportHistory/exportChat/backup/usage-export; only CSV file renderers and package-registry links
Finding: No history, usage or task export in code.
Retrieved: 2026-11-12

## thinkrail:OWN-08

Finding: Free outright: Apache-2.0 source with free desktop and CLI downloads and no paid plan, card, trial, credit programme, gated early access or usage caps. Meaningful evaluation needs only provider credentials (JetBrains AI or own keys/local models); two-person same-work collaboration is limited by the single-user design.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-01-11
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Evaluation needs provider credentials; same-work two-person scenarios are limited by the single-user design.

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/architecture.md
Locator: Drivers; Topology — three rings
Finding: Engine host (Bun HTTP+WS with one in-process pi session per chat) launched by the CLI or the Electrobun desktop shell; typed versioned wire protocol; mobile-first React UI that dials any host over the network, with a phone reaching the selected host over Tailscale. Desktop profile is local only; a later shared-client profile can dial an existing host. Bundled extensions pi-spec-graph, pi-thinkrail-workflow and pi-todos; portable packages pi-delegation, pi-background-commands and pi-subagents (Agent plus get_subagent_result tools) bundled into every parent session.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/releases
Locator: Releases list; per-release version and date
Finding: Stable v0.3.2 published 2026-11-06; v0.4.0 stable published 2026-11-12 (latest at check time). Free desktop and CLI assets per platform with SHA256SUMS.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/LICENSE
Locator: License grant
Finding: Repository licensed under the Apache License, Version 2.0.
Retrieved: 2026-11-12

## thinkrail:OWN-09

Finding: Pricing is transparent because there is nothing to hide: free with no paid plan, no metered units, no overages, no markups, no minimums and nothing sales-gated. Model and compute economics are the user’s own provider and hardware spend, never marked up.

Verification: agent-cross-checked
Checked: 2026-11-12
Scheduled recheck: 2027-01-11
Plan: Not specified
Surface: ThinkRail desktop app (Electrobun system-webview); thinkrail CLI browser host (same app in a browser)
Version: v0.3.2 stable (2026-11-06); default-branch commit e473363 (2026-11-12)

Billing atoms do not apply to a free product with no paid tier.

Source: https://github.com/JetBrains/thinkrail/blob/main/README.md
Locator: Installation; What you get; Installation details; Analytics & privacy; Under the hood
Finding: Native desktop installer plus self-contained thinkrail CLI with stable and nightly channels and checksum verification. Workspaces are git worktrees with own branch and cwd; finished ones settle after PR merge/close or a quiet week. Concurrent sessions per workspace each with its own model; shared TODO plans with per-step review; subagents and background commands watched from a per-chat Resources view; spec tools; skills import from Claude/Codex agents; MCP from pi mcp.json; JetBrains AI or any pi provider auth with no ThinkRail accounts. App state lives under ~/.thinkrail. Basic usage events tie to a random install ID; extra sharing is opt-in via Settings Privacy or --no-analytics.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/goal-and-requirements.md
Locator: Value; Principles; Capabilities; Non-goals
Finding: pi is the only engine, run in-process, with no second runtime. Git, GitHub and model access go through the user-owned git, gh and central CLI plus pi provider auth; ThinkRail keeps no accounts or tokens. Cloned-repository resources and repo MCP servers load only after a per-project trust grant. Capabilities include projects-to-workspaces, scratch chats, concurrent steerable chats, plans with per-step independent review, subagents and background commands, agent-started workspaces, anchored review comments, PR open/update via gh, specs, workflows, providers, pi config, agent tools, pi packages and MCP. Non-goals: a second agent runtime, and ThinkRail accounts or a login UI — who may reach a host is decided by Tailscale ACLs.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/central-integration.md
Locator: The chain; Quota chain
Finding: JetBrains AI models reach ThinkRail through the user-owned central CLI with a recurring AI-credit quota; sign-in, status and quota orchestration span the provider card and shell, with quota snapshots on a 1–3600 second cadence (30 seconds by default).
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/releases
Locator: Releases list; per-release version and date
Finding: Stable v0.3.2 published 2026-11-06; v0.4.0 stable published 2026-11-12 (latest at check time). Free desktop and CLI assets per platform with SHA256SUMS.
Retrieved: 2026-11-12

Source: https://github.com/JetBrains/thinkrail/blob/main/LICENSE
Locator: License grant
Finding: Repository licensed under the Apache License, Version 2.0.
Retrieved: 2026-11-12