Hivecode
ICR · intent-aware code replication
Two AI agents edit one repo. One renames a function; the other adds a call to the old name. Git compares lines, finds no overlap, and reports success — then your build dies at runtime. Hivecode merges by structure and intent: it recognises the rename, rewrites the stale call site, and refuses to emit code that doesn't parse.
$ npx git-clash scan
See the benchmarks
of independent feature pairs conflict when merged with git — on professionally written patches, not agent output
CooperBench · 505 of 652 pairs
more of those conflicts integrated cleanly by ICR than by mergiraf, the best free structural merger
40.8% vs 11.1%
of ICR's integrations pass both features' own test suites — verified, not asserted
50 of 52 scoreable pairs
unparseable merges across 6,430 real Python conflicts, checked with CPython's own parser
ConGra · 0 crashes
the failure class
None of these produce a conflict marker. None fail a linter. All three are what happens when a tool that only understands lines is handed code that only makes sense as structure.
Agent A removes a helper it believes is dead. Agent B, at the same time, writes a new caller for it. The edits touch different lines, so git merges happily.
// agent A removes it
- function formatCents(n) { … }
// agent B adds a caller
+ total = formatCents(sum) ICR resolves references after merging and reports ref:formatCents — clean: false, so nothing ships silently.
In a live CRDT editor two agents change the same value at once. Both inserts survive with distinct identities, in deterministic order. Every peer converges — on a number neither author chose.
base return 1
A return 2
B return 3
merged return 23 ← valid, convergent, unauthoredSigned provenance keeps both real versions, so the fused text — which nothing attests — is detected and surfaced as a genuine conflict.
Both agents rewrite the same function — one adds rate limiting, one converts it to async. Any merge that silently picks a winner throws away work somebody asked for.
{ key: 'fn:login',
base, ours, theirs,
oursIntent: 'add rate limiting',
theirsIntent: 'make login async' }The conflict is emitted as a machine-resolvable object carrying both intents — an agent can reconcile it, and the engine re-validates the result before it lands.
how it works
The engine is open source and runs anywhere — as a library, as a git merge driver, or live inside a shared workspace.
Each version is parsed and split into keyed units — fn:login, class:Auth, import:./db. The key is identity, so “the same function in all three versions” is a fact, not a guess. Changed on one side wins; changed on both descends a tier: statements, then lines, then tokens.
import { merge } from 'icr-merge'
const r = merge(base, ours, theirs, { filename: 'auth.js' })
// r.method → 'structural' | 'rename' | 'lines'Every merged unit and every final result is re-parsed before it is allowed out. If it doesn't parse, the engine refuses and falls back to a line merge — so the floor is exactly git, never worse. Held across thousands of fuzzed merges per run and 6,430 real conflicts.
// all three inputs parse but the result doesn't?
{ clean: false,
warning: 'line-merged text does not parse' }Agents sense a shared claim map, take a lease, verify after sync, and back off if they lost the race — Ethernet's collision detection with ant-colony expiry. There is no coordinator, and a crashed agent's claim evaporates on its own TTL instead of deadlocking the room.
SENSE → is this file taken?
FLOW → if so, move to an open one
CLAIM → { by, intent, at, ttl }
VERIFY → re-read after sync; lost? back offEach edit is an Ed25519-signed receipt over author, the exact state it was made from, the result, and the intent. Author identity is the key's own fingerprint, so there is no account database. Unattributable bytes stand out precisely because nobody signed them.
{ author: fingerprint(pubKey),
parent: sha256(stateEditedFrom),
content: sha256(result),
intent: 'add rate limiting to login' }receipts, not adjectives
CooperBench (Stanford, 2026) gives two agents independent features on one repo and scores the result by running both features' test suites. Its 652 gold pairs are professional human patches — the cleanest possible input. 505 of them still conflict under git. Here is how much of that loss each merge layer recovers.
| Merge layer | Pairs integrated | Share | Passes both test suites |
|---|---|---|---|
| git mergeline-based, the baseline | 0 | 0% | — |
| mergiraf 0.18tree-sitter structural | 56 | 11.1% | — |
| ICR — safe defaultstructure + intent | 112 | 22.2% | 100% 27 / 27 |
| ICR — union modethe multi-agent policy | 206 | 40.8% | 96.2% 50 / 52 |
Replay real OSS conflicts and compare each tool's output against what the maintainer actually committed. ICR matched 87; mergiraf 64. Zero broken outputs, and ICR led on all five repositories.
Verified with CPython's own ast.parse. ICR resolves 32.1% to mergiraf's 31.8%, with zero crashes and zero parse-guarantee violations. Running it found and fixed 17 real engine bugs first.
Symmetry (M(b,x,y) = M(b,y,x)), fixed-point, no-loss and the parse guarantee, under seeded fuzz across 20+ languages — 13,000+ assertions, green. Convergence isn't a nicety: without it, live peers diverge.
$ node scripts/cooper-merge-bench.mjs
Every harness and raw receipt is in the repo — reproduce it, don't trust it.
upstream of the merge
A merge engine is a safety net. The stronger move is a shared medium: agents and humans on one live workspace, seeing each other's edits in about a second, with no push, no pull, and no branch to reconcile later.
hive_join and live in a hive_wait loop — no scripts, no polling.
three ways in
Each of these is published and installable right now.
Replays your repository's own merge history and reports the merges that were clean to git but semantically broken. Read-only, entirely local.
$ npx git-clash scan
The engine as a library, a CLI, and a three-line git merge driver — so every git merge and rebase in your repo starts merging by structure instead of by line.
$ npm i icr-merge
The live medium for agents: claims, chat, task approval, presence and provenance, exposed as MCP tools any capable agent can call natively.
$ npx hivecode-mcp
pricing
ICR is MIT-licensed and always will be — merge safety shouldn't be a paywall. Pro is for teams running agent fleets on a shared workspace, where enforcement, isolation and audit are what actually matter.
Free
Everything an individual developer needs.
git-clash auditsno account, no telemetry
Pro
For teams running AI agents on a shared codebase.
Total $29 / month
A committer is one agent or human writing to the room at the same time. Idle agents, reviewers and read-only clients don't count — you pay for concurrent writers, not for how many agents you have configured.
Enterprise
For teams whose code cannot leave their own infrastructure.
deployed on your infrastructure
straight answers
It guarantees structure, not semantics. If two agents invent two different database schemas, ICR will merge both side by side into code that runs — deciding which schema is right is a product judgement, not a merge one. A comment and code edited on the same side can lose the comment. Languages without a full parser have weaker validation unless the tree-sitter oracle is enabled. And when an AI resolves a conflict, its answer can be semantically wrong while structurally valid — the engine verifies the shape, never the meaning.
No. ICR installs as a git merge driver, so it improves the merges you already do. The live medium is for the minutes between commits, where git has nothing to say. And the fallback tier is plain diff3 — the floor is exactly git's behaviour, never worse.
20+. Full AST merging for JavaScript and TypeScript; structural and intent-aware merging for Python, Ruby, Go, Rust, Java and the C family; JSON merged as parsed data rather than text; YAML and TOML by keyed structure. An optional tree-sitter oracle upgrades the parse gate with real grammars for 15 of them.
git-clash and icr-merge run entirely on your machine and send nothing anywhere. For live rooms the relay forwards encrypted-in-transit CRDT updates and keeps no canonical copy of your repository; folder scoping means an out-of-scope file never reaches a participant at all. You can self-host the relay, and the trust root is a key you hold — there is no account database.
That's today's default, and it's a deferral rather than a fix: it converts live coordination into a merge you deal with later. CooperBench measures the cost — three quarters of independent feature pairs conflict, on professionally written patches. Isolation doesn't reduce that number; it just decides when you meet it.
One command, read-only, no signup. It replays your merge history and tells you which “clean” merges weren't.
$ npx git-clash scan
Read the source