Run two coding agents on one repository at the same time and the first thing they fight over is files. JetBrains' open-source IDE ThinkRail answers that by giving each workspace its own git worktree.

Reading the repository README, the conclusion is that worktrees solve file collisions and do not solve design collisions. This post shows that difference with a locally executed example, and separates ThinkRail's current features from planned ones. I have not installed or run ThinkRail. Everything about ThinkRail below comes from the README; the only thing I executed was ordinary git.

What the README lists as current

ThinkRail is an Apache-2.0 IDE wrapped around the pi coding agent, used as a desktop app or a browser-based thinkrail CLI. Per the README, these exist today:

  • Workspaces: each workspace is a git worktree with its own branch and directory, so agents work in parallel without touching your checkout. Finished workspaces, or ones quiet for a week, move to a shelf. You can also attach existing worktrees or work in the project folder directly.
  • SPEC.md graph: a connected graph of SPEC.md files sits beside the code. The agent reads, searches, and updates it through spec_* tools, and a read-only Specs tool shows it as a tree.
  • MCP tool approval: it uses MCP servers from pi's mcp.json and asks in chat before calling tools not marked read-only. You can pre-approve trusted tools per project, and servers defined by a repository stay disabled until approved.
  • Also: per-chat models with token and cost readouts, review comments on files and diffs, PR creation through gh, and reading existing Agent Skills.

What is only planned

The README's forward-looking statement is a single sentence: it is adding full extension support so ThinkRail can create the tools it needs based on how you work. It gives no mechanism or date. A "tool-creating IDE" should therefore not be read as a current feature. The tagline about an IDE that gets better with use is also the README's wording, and I found no evidence behind it.

The first public date is unconfirmed too. The README has no launch date; from the releases page I confirmed that v0.2.0 (October 18, 2026) is the latest stable release and that 0.3.0 nightly pre-releases run through October 28. A secondary source mentions an August launch, which I could not verify.

File collisions versus design collisions

What a worktree does is precise: it shares one repository (.git) while separating branches and working directories. Two agents can no longer overwrite the same file at once. But if two branches edit the same design document differently, they collide when merged.

The script below was run in a temporary directory. Two agents each append something different after the same contract line in api/SPEC.md in their own worktree, and commit.

git worktree add -q ../ws-a -b agent/a
git worktree add -q ../ws-b -b agent/b
# ws-a: add "GET /items returns {items: [...]}" and commit
# ws-b: add "GET /items supports ?limit" and commit
git merge -q agent/a              # fast-forward
git merge --no-edit agent/b       # conflict

/privateTMP/app   efbe9f0 [master]
/privateTMP/ws-a  425311a [agent/a]
/privateTMP/ws-b  5eaa885 [agent/b]
--- main SPEC.md untouched:
# api
Contract: GET /items returns a JSON array.
merged agent/a (fast-forward)
CONFLICT (content): Merge conflict in api/SPEC.md
<<<<<<< HEAD
Contract: GET /items returns {items: [...]}
=======
Contract: GET /items supports ?limit
>>>>>>> agent/b

Main's SPEC.md was untouched until the merge, and the two workspaces could not see each other. Yet one agent changed the response shape while the other added a query parameter, so catching this as a textual conflict was lucky. Had the lines landed apart, git would have merged them silently and left two contradictory contracts (this part is inference from how git merging generally works, not something the run above confirmed).

Trying parallel agents without ThinkRail

The same structure can be tested with plain git.

  1. Split the work into units whose file boundaries do not overlap.
  2. Give each unit a worktree and branch, and attach one agent to it.
  3. Pull any task that must touch the contract (SPEC.md or an interface document) out of the parallel set and settle it in one place first.
  4. Run the same tests on every branch before merging.

The benefit can only be shown by comparison. Run the same task with one agent serially and with worktree-parallel agents, and record elapsed time, merge conflicts, test pass rate, and cost. I measured none of this.

Limits and cautions

  • Requirements (macOS 14+, Windows x64, Linux x64/ARM64), the signed-but-not-notarized macOS CLI, and analytics that are on by default (off with --no-analytics) are limits the README states itself.
  • When an agent updates SPEC.md, the design document becomes agent output too. Without a human review path, the document drifts along with the code.
  • This article does not judge ThinkRail's quality or productivity gains. I did not use it.

Takeaway

Worktrees are a cheap and reliable way to prevent file collisions among parallel agents. Design collisions are a question of who settles the contract first. What makes ThinkRail interesting is that it binds worktrees, specification documents, and tool approval into one workspace; extension generation is still only a promise.

The paid promotion at the end covers using Claude Code properly and assembling a harness. It is not a course on ThinkRail or JetBrains products.

Related reading

Sources