No two agents edit the same file.
Claude, Codex, Gemini, and Cursor on one repo — Regente gives each agent a lane, blocks the collision before it reaches main, and hands the file to the next agent the moment the first is done. Local-first, cross-tool, pre-merge.
curl -fsSL https://get.regente.dev | bash 
Works with what you run
Coordinate the agents you already have open.
Regente attaches to your running agents through MCP and session hooks. No new runtime, no orchestrator, no rewriting your workflow.
Join, don't spawn
Regente coordinates the sessions you've already started — it never spawns or replaces your agents.
Every vendor, one repo
Claude Code, Codex, Gemini CLI, and Cursor coordinate as equals today. No one else is neutral across all four.
public/index.html ← cursor ⛔ blocked · pre-merge server/export-api.js ← codex ⚠ territory · backend lane Caught before merge
The instant two agents reach for the same file, Regente blocks it — pre-merge, cross-vendor, before a line is lost.
A lane for every role
Give each agent a role and the files it owns. Everyone — and you — can see who owns what at a glance.
The part nobody else does
It doesn't just block. It hands off.
A lock would tell the second agent “no” and leave it stuck. Regente queues it, tells it exactly what to do, and the instant the first agent releases the file, hands it to the next one in line — automatically, with a note. No idle agents, no clobbered work, no human merging.
public/index.html editing now public/index.html ✓ auto-handed off — start editing Claim → queue → release → owned
The collision resolves itself while you watch. The second agent never waits idle and never overwrites the first.
A coordination layer, not a lock
The blocked agent gets an actionable plan — wait for the auto-handoff, or move to another file it owns — not a dead error.
Why Regente
Worktrees just defer the problem.
The industry's answer to parallel agents is to isolate each one in its own git worktree — which only moves the collision to merge time, with no warning, across no shared view.
“Why did two agents touch the same file again?”
Because nothing was watching across them. Regente sees every vendor's agent at once and stops the second one before it edits.
“Where do the conflicts actually get caught?”
At claim time — before the edit lands. Worktrees defer conflicts to merge; review tools catch them after the PR. Regente is the only one that's pre-merge.
“Which tool is neutral across all my agents?”
None of them. Agent Teams is Claude-only; GitHub is merge-time. Regente is vendor-neutral by design — Claude, Codex, Gemini, and Cursor as equals.
The honest comparison
Where the collision actually gets caught.
Worktrees defer it to merge. Agent Teams is one vendor. Review tools catch it after the PR. Regente is the only layer that’s pre-merge and cross-vendor — at the moment a second agent reaches for the file.
| Regente | Git worktrees | Claude Agent Teams | Merge-time review | |
|---|---|---|---|---|
| Vendor-neutral Claude · Codex · Gemini · Cursor as equals | Yes | Not applicable tool-agnostic, but blind across agents | No Claude-only | Yes |
| Catches conflicts pre-merge at claim time, before the edit lands | Yes at claim | No surfaces at merge | Partial task-level | No after the PR |
| Auto-hands the file to the next agent the moment the holder releases it | Yes | No | No | No |
| One live view of the whole fleet every vendor, one screen | Yes | No each worktree isolated | Partial Claude agents only | No |
| File-level claims across vendors not just task assignment | Yes | Not applicable | No task-level | Not applicable |
| Joins the agents you already run never spawns or replaces them | Yes | Not applicable | No spawns teammates | Not applicable |
| Cross-vendor record of who changed what the pre-merge system of record | Yes | No | No | Partial at merge |
“Merge-time review” = GitHub PRs, CodeRabbit, Greptile — they run once a pull request exists, after the work diverged. The closest tool in spirit is the open-source MCP Agent Mail — its file leases are advisory by default, with optional enforcement only at commit time (a pre-commit guard), and no live cross-vendor GUI. Regente enforces at claim time, before the edit lands, with a live fleet view — pre-merge and cross-vendor at once.
FAQ
Questions, answered.
Is it free?
Yes — the desktop app and CLI are free to use. A paid team tier is coming for cross-vendor attribution and governance.
Does it work with my agents?
Claude Code, Codex, Gemini, and Cursor are all supported today — they coordinate on one repo as equals.
Where does my code go?
Nowhere. Regente is local-first — its coordination data (claims, lanes, history) stays on your machine and never leaves it. Your agents still talk to their own model providers, just as they do today; Regente adds no server and sends your code nowhere.
Regente for teams
Accountable for what your fleet ships?
The desktop app is free. We're building the team tier — cross-vendor attribution, a signed system-of-record, and governance for who-may-edit-what. Get early access.
Stop the next collision.
Install once. Regente wires up your agents and runs entirely on your machine.
curl -fsSL https://get.regente.dev | bash