Parallel agents, no silent overrides

gitaccord is a set of git hooks for teams of AI coding agents. Agents keep using plain git; the hooks make them see each other's plans, agree on approaches that keep everyone's feature, and refuse to land a change that breaks another agent's work unless it's declared for human review.

Source on GitHub Read the design

A real case from our tests. Two agents were asked for opposite defaults. With plain git, whoever landed last quietly won. With gitaccord, the second landing was refused until the agent declared the override, so the trade-off reaches a person instead of disappearing.

The problem isn't merge conflicts

Capable agents resolve textual conflicts on their own. The real failure is quieter: the agent that lands last rewrites another agent's feature to fit its own, updates the tests to match, and reports success. Nothing looks wrong until someone notices the feature is gone.

With plain git, and agents merging and landing their own work, this happened in 24–28% of our test runs, and which feature survived depended on who finished last.

How it works

Each agent works on its own agent/<name> branch and keeps a plan, notes to other agents, and a user-level acceptance test as ordinary files in the repo. Every commit says why in a Why: line. The hooks act at the three moments git already has:

CommitCode waits until the plan is committed. Afterwards, the agent sees whose work overlaps with its own, including work already on main, with their plans, reasoning and notes, each shown once.
MergeAfter git merge main, the agent sees whose work just came in and why, so it integrates with their intent in mind.
Push to mainLanding is refused while an overlap has no recorded agreement, or while another agent's own tests fail on what's being landed, unless the agent declares Override:, which always goes to a human.

landing rejected: your changes break other agents' work, judged by their own tests:
  a: their tests fail on what you're landing (tests/acceptance/a.test.ts)
Either:
  - keep their behaviour (adapt your code so their tests pass), or
  - if you must change it, add "Override: <agent> — <what and why>" to your plan.
    Overrides are always flagged for human review.

Agents sign their commits with their own keys, so notes from an unregistered or impersonating agent are never shown.

What we measured

About 300 runs on toy projects with deliberately clashing features, using Claude Code (Sonnet) and pi (GLM 5.3 Flash), each compared with plain git where agents also land their own work.

Result	Plain git	gitaccord
Runs where a feature was silently overridden	24–28%	0%
No-win trade-offs recorded and flagged for a human	never	always
Designed clashes detected	–	100%
Runs leaving main broken	0–2%	0%
Extra model tokens	–	1.2× Claude, 2.3× GLM

Still open

Coordination costs GLM 2.3× the tokens of plain git, against a 1.5× target. Adapters for pi and Claude Code that deliver notices without commit-and-poll come next.
With six agents under heavy load, one hook call in a few hundred still takes over half a second. A compiled binary and batched reads are planned.
The landing check only protects what each agent's own tests cover.