ThinkRail: JetBrains' agentic IDE where each agent works in its own git worktree

ThinkRail: JetBrains' agentic IDE where every agent works in its own git worktree

🔎 The day agents learned to stop stepping on each other

On October 28 and 29, 2026, a JetBrains repo took first place on GitHub Trending with +1,068 stars in a single day. It's called ThinkRail, it's from JetBrains InnovationHub, licensed under Apache-2.0, and it offers a disarmingly simple answer to a problem every agentic developer knows: agents working in parallel step on each other.

The starting observation fits in one sentence, displayed prominently on the official site: "Agents deserve worktrees, not your working tree". Your agents deserve worktrees, not your working copy. Each agent session runs in its own git worktree, with its own branch and directory — the main branch stays clean until the merge.

Why now? Because running three agents in parallel has become as routine as opening three tabs. But a git repo remains, by default, a single-player space. The harness layer is becoming an infrastructure in its own right, and ThinkRail may be its most visible building block to date.

Key Takeaways

• One worktree per agent: each chat = an isolated git worktree (its own branch + directory). Multiple agents modify the repo without stepping on each other, and the main branch stays untouched until the merge.
• Open-source and free: Apache-2.0 license, incubator project of JetBrains InnovationHub, engine = the open-source coding agent pi (not Junie).
• #1 on GitHub Trending on October 28-29, 2026: +1,068 stars/day, ~5,280 total, 271 forks, 604 commits (metrics via GitNova).
• Spec-driven: SPEC.md specs linked in a graph, you launch an agent from a spec.
• Extensible: MCP servers + portable Agent Skills, desktop app or browser UI via the thinkrail CLI. PRs via the gh CLI, with no stored token.

Recommended Tools

Three agents, one repo: the problem nobody wanted to name

The bottleneck of agentic development in 2026 is no longer the model: it's the working copy. We have models that code like seniors — Claude Opus 4.7 (Adaptive), GPT-5.5, Gemini 3 Pro Deep Think — but they're all fighting over the same directory.

Try it yourself: launch three agents on three features. Twenty minutes later, git status looks like a battlefield. Agent A refactored a file that agent B was in the middle of modifying. Agent C ran the tests on an inconsistent state of the code. You spend all your time stashing, reverting, arbitrating.

The problem isn't the agents' competence. It's an assumption inherited from the 2000s: one repo = one checkout = one person. That equation was true for humans. It's false for agents, who don't complain about working six to a folder — they silently break it.

JetBrains didn't invent git worktree. But it's the first major company to make it the fundamental building block of an IDE, rather than a command that the bearded folks pull out once a year.

"Agents deserve worktrees, not your working tree"

ThinkRail's answer boils down to one rule: one agent session = one worktree = one branch. Every new chat automatically creates its own working directory, with its dedicated branch, under ~/.thinkrail/worktrees. You only touch the main working copy to merge.

For those who have never used the feature: git worktree lets you create multiple checkouts of the same repository, each on its own branch, all sharing the same .git. Concretely:

git worktree add ../feature-login -b feature/login

A feature-login directory appears, checked out on feature/login, while your main directory stays on main. ThinkRail automates this whole dance: every agent session gets its worktree, its environment, its dependencies. Zero file conflicts, zero stashing, zero "wait, let me revert what the other agent did."

One Default workspace, external worktrees

The project's documented architecture is crystal clear: one Default workspace per project, plus external worktrees you can attach. The Default stays on your main branch; all agent work happens elsewhere, then comes back via merge after review.

This is the workflow the team has had in mind since the project was presented on August 19, 2026 by Maciej Gorywoda: every session on a separate branch, merged after review. Isolation isn't a gimmick, it's the contract. The agent works, you review the diff, you merge. Exactly like with a human collaborator — except this one never gets tired.

Under the hood: pi, Monaco, and zero stored tokens

ThinkRail isn't Junie in disguise: its engine is pi, an open-source coding agent. This is a point that specialized sources like Fresh Weights emphasize: the IDE is built on the Monaco editor (the one from VS Code) with pi as the agent engine. Junie, JetBrains' proprietary agent, has nothing to do with it.

This choice is no accident. An open-source engine means the agent-tools-model loop is auditable, scriptable, and replaceable. You can plug in the current frontier models — Claude Opus 4.7 (Adaptive) for heavy refactors, GPT-5.3 Codex for pure code, Gemini 3.1 Pro for analysis — or self-hosted models like GLM-5 (Reasoning) or Kimi K2.6 if your code must never leave your infrastructure.

Second bold choice: PRs with zero stored tokens. When you click "Open PR", ThinkRail pushes the branch and opens the pull request via the user's gh CLI. No OAuth token stashed away somewhere, no call to a forge's REST API. Your credentials, your machine, your responsibility.

Third point worth knowing: ThinkRail is an incubator project. External dependency on pi, short history, an API likely to change. Nothing alarming for a tool moving at this pace, but don't migrate your production pipeline to it tomorrow morning.

The spec graph: your SPEC.md files become a living map of the project

ThinkRail's second pillar is spec-driven development: every task starts from a spec, and the specs are connected in a graph. No volatile prompt lost in a chat history — a SPEC.md file, versioned, linked to the other specs of the project.

Why does this matter? Because context is an agent's scarcest resource. A spec graph gives the agent a map: this spec depends on that one, this module implements that contract. You launch an agent from a spec, it works in its worktree, and the spec serves as the acceptance criterion at review time.

It's also a win for collective memory. A new developer — or a new agent — reads the graph and understands the architecture in an hour. Disposable prompts don't survive the week; a spec graph does.

My take: this is the project's most underrated feature. Everyone talks about worktrees — rightly so — but the spec graph is what makes the parallelism governable. Without a spec, three parallel agents = three divergent interpretations of the requirement. With a graph, three agents = three branches of the same plan.

MCP and Agent Skills: First-Class Extensibility

ThinkRail supports MCP servers and portable Agent Skills, and that's what connects it to the biggest GitHub trend of the fall. Skills — those capability packages that agents load on demand — are taking over the trending charts, as I detailed in Skills are taking over GitHub Trending: obra Superpowers and Matt Pocock Skills.

The logic is the same everywhere: agent capabilities become versionable, shareable, auditable artifacts. A portable skill written for one agent works for another. In ThinkRail, your skills follow your sessions into their worktrees — the agent testing an API in its corner has access to the same HTTP skill as the one writing the docs.

That's also the direction of history on the open-source side: GenericAgent, the open-source AI agent that builds its own skill tree, had paved the way with its 6,700 stars in one week. ThinkRail applies the same philosophy from an IDE: the model's intelligence is fixed, capabilities are composable.

Concretely, for a developer: your MCP servers (database, browser, ticketing) are declared once, and every worktree inherits them. You don't reconfigure each agent's environment for every session. It sounds obvious. No IDE did it properly before.

The numbers: +1,068 stars in a single day, and the curve isn't slowing down

On October 29, 2026 at 4:58 AM UTC, ThinkRail had 5,280 stars, 271 forks and 604 commits, with a pace 4.1 times higher than the previous week (measurements by GitNova). The repo finished the day #1 on GitHub Trending with +1,068 stars in 24 hours.

The trajectory is worth a closer look:

• August 19, 2026: official presentation by Maciej Gorywoda on the ThinkRail blog.
• October 25: first appearance on the Hacker News front page (169 points), the repo reaches ~4,600 stars (Fresh Weights).
• October 28-29: second HN wave at 242 points, #1 GitHub Trending of the day, +1,068 stars, coverage on ai-daily.dev.

Two waves in five days, the second stronger than the first: this isn't the profile of a launch spike, it's the profile of adoption spreading through technical word of mouth. The HN discussions revolve around the same surprise: "why hadn't anyone done this before?"

My take: worktrees are the idea everyone had in the back of their mind for six months, but that no one had dared put at the center of a product. JetBrains, through its incubator, has nothing to lose — and it shows in the boldness of the design.

ThinkRail versus other agentic IDEs: the parallelism battle

What sets ThinkRail apart isn't the quality of the agent, it's the handling of parallelism. Most agentic IDEs have added multi-agent as an option; ThinkRail is designed from multi-agent.

Let me be clear: nothing prevents you from replicating this workflow with Claude Code and three git worktree commands. The hardcore folks are already doing it. But there's a difference between possible and default. As long as a good practice requires manual discipline, it remains a minority practice. The day it's built into the tool, it becomes the norm.

For a broader comparison of today's agentic IDEs, our selection of the best AI tools for code (Cursor, Copilot, Cline) is continuously updated.

Scaling up: agents that work while you sleep

The next step, once parallelism is mastered, is asynchrony. In My AI agent works while I sleep — and it changes everything, I describe what a developer's day becomes when long tasks run overnight. ThinkRail fits exactly into this pattern: three sessions launched in the evening, three worktrees, three branches — and in the morning, all that's left is the review.

For a complete 24/7 setup on a controlled budget, I detailed how to create an AI agent that works 24/7 for €29/month — a Hostinger VPS is more than enough to host the agents' execution environment, with the IDE remaining on your machine.

Get started with ThinkRail in ten minutes

The onboarding path takes six steps, and it requires no prior git worktree expertise.

1. Grab the project from GitHub and launch the desktop app — or the thinkrail CLI if you prefer the browser UI.
2. Open a project: a Default workspace is created, aligned with your usual working copy.
3. Create one session per task: ThinkRail automatically generates the corresponding worktree and branch.
4. Write your SPEC.md files and link them into a graph. One spec = one testable intent.
5. Run multiple agents in parallel on different specs, and monitor the diffs from your IDE.
6. Review, merge, open the PR — the push and pull request go through your gh CLI, with no stored token.

As for models, my recommended setup to start with: Claude Sonnet 4.6 for routine tasks (fast, economical), Claude Opus 4.7 (Adaptive) or GPT-5.5 for cross-cutting refactors, and GPT-5.3 Codex if you live in the terminal. All three run in parallel without seeing each other — that's precisely the point.

❌ Common mistakes

Mistake 1: confusing a worktree with a full clone

A worktree is not a clone: it shares the parent .git's object store. The disk cost remains low, but branches and refs are shared. If you delete a worktree by hand, you can leave orphaned refs behind. Read the architecture.md of the project before tinkering outside the tool.

Mistake 2: using the Default workspace as a playground

The Default workspace exists to represent your main branch. If you let an agent experiment in it, you recreate exactly the problem ThinkRail solves. Simple rule: all agent work goes into a dedicated worktree, the Default stays clean.

Mistake 3: merging without reviewing because "it's an agent"

Worktree isolation protects your files, not your judgment. An agent can produce flawless code in its worktree and implement the wrong spec. The JetBrains workflow is explicit: review then merge. The spec serves as an acceptance contract — use it.

Mistake 4: believing ThinkRail is Junie in open-source

No. Different engine (pi, not Junie), different philosophy (systematic isolation vs in-editor assistance), different license (Apache-2.0). And keep in mind that the project is a JetBrains incubator: the roadmap can change quickly, in either direction.

❓ Frequently Asked Questions

Is ThinkRail really free?

Yes. The code is licensed under Apache-2.0, the desktop app and the thinkrail CLI are free. You only pay for your agents' consumption: model calls (Claude Opus 4.7, GPT-5.5, etc.) or hosting a self-hosted model like GLM-5 or Kimi K2.6 on your own infrastructure.

What's the difference with Junie?

Junie is JetBrains' proprietary agent built into the IDEs. ThinkRail is a separate project from the InnovationHub: it is built on the open-source pi engine and makes worktree isolation its fundamental rule, whereas Junie assists the user within their editor. Two products, two use cases, two philosophies.

Which models can I plug in?

The main providers are supported via pi: Claude Opus 4.7 (Adaptive) and Sonnet 4.6 for code, GPT-5.5 and GPT-5.3 Codex, Gemini 3 Pro Deep Think, or self-hosted models like GLM-5 (Reasoning) and Kimi K2.6 if your code must never leave your infrastructure.

How many agents can run in parallel?

The limit is your machine, not the software. Worktrees share the same .git, so disk cost stays low; it's CPU, RAM, and tokens that cap out. On a 32 GB laptop, three to five sessions run without friction according to user feedback.

Do you need to master git worktree to use it?

Not to get started: ThinkRail creates and cleans up the worktrees for you. Yes, for the long run: understanding the mechanics — one .git, multiple checkouts, one branch per directory — will spare you unpleasant surprises at merge time and make you formidable in the CLI as well.

✅ Conclusion

ThinkRail reinvents neither the agent nor the model: it reinvents where the agent works — and that may well be the real frontier of 2026. Star the GitHub repo, read the introductory post, then launch two agents in parallel on your biggest repo: you won't look back.