Vision
Why we are building Regente.
More and more code is written by coding agents, and most people who lean on them run more than one. We think the hard part is about to shift from writing the code to trusting what a fleet of agents did to your repo. Regente is our attempt at the layer that makes that safe.
Where things are heading
Not long ago, running two coding agents at once was unusual. Now it is normal to have Claude, Codex, Gemini, Cursor, or another agent CLI open on the same project, sometimes several at the same time. Each one is capable. None of them can see the others. So two agents reach for the same file, both edit it, and you only find out when you go to merge. The common workaround is to give each agent its own git worktree, but that does not prevent the collision. It just hides it until merge time, with no warning in between.
What we believe
Coordination should happen before the merge, not after, and it should be neutral across vendors. No single AI company is going to coordinate every agent fairly, because each one wants you to standardize on its own stack. A neutral layer that gives each participating tool the same claim/queue/handoff protocol is the honest place for this to live, and it is the part an incumbent cannot really own.
What we built first
So we started with the most painful part: stopping cooperating agents from accidentally editing the same file. In Regente, an agent claims a file before it edits. If a second participating agent reaches for that file, Regente blocks the second claim before a line is lost. Instead of leaving that agent stuck, it puts it in line, and the moment the first agent is done, the file is handed to the next one automatically, with a note. Nobody waits idle, and nobody clobbers anyone else's work. This part is free, it runs entirely on your machine, and it works across the supported adapters and MCP/manual attach path.
We build Regente with Regente
We run this on ourselves. The site you are reading, the engine behind it, the docs, and the release tooling are each built by a separate coding agent working in the same repo at the same time, coordinated by Regente. When two of them reach for the same file, the second is queued and handed the file when the first releases it. If the idea did not work, it would fall apart on us before it ever reached you.
Where it goes
Every claim and message is signed and written to an append-only log. Over time that becomes something more useful than a set of warnings. It becomes a durable, cross-vendor record of which agent changed what, and when, before any of it merged. We think that record is the foundation for what a team needs once a named person is accountable for what the fleet ships: attribution, so you can tell who did what; verification, meaning the signed log of what the fleet actually did, not code review; and governance, meaning who is allowed to touch what.
To be clear about where we are today, this is the direction, not a finished product. The coordination layer is real and in daily use. The paid governance tier is barely started, and we would rather say that plainly than dress it up.
How we work
- Local-first. Your code stays on your machine. Regente adds no server of its own, and your agents talk to their own model providers exactly as they did before.
- Join, do not spawn. We coordinate the agents you already run. We never launch them or replace them.
- Neutral by design. Claude, Codex, and Gemini have repo-local adapters today; Cursor and other CLIs can coordinate through MCP/manual attach while native hooks mature. We are not affiliated with any of them.
- Coordinate, do not just lock. A lock says no and walks away. We queue the blocked agent and hand it the file the moment it frees up.
- Honest about stage. We are early. Free, local-first, macOS on Apple Silicon and Intel, no revenue yet. We say what is built and what is not.
The bet
The number of agents writing code is only going up. The bottleneck is moving from how fast they write to whether you can trust and account for what they did together. We want Regente to be the neutral, pre-merge layer that makes a cooperating mixed fleet of agents safer to run, and accountable for what it ships.