The End of the Line: How Ataraxy-Labs/weave Teaches Git to Understand Code
Line-based version control is breaking under the weight of concurrent AI agents. A new semantic merge driver operates entirely on functions and classes.
- Weave abandons line-based merging in favor of semantic identity, tracking functions and classes regardless of their physical position in a file.
- Unlike AST-based tools that generate noisy node-level conflicts, Weave provides human-readable resolutions at the entity level.
- A built-in Model Context Protocol server allows AI agents to coordinate and claim entities before editing, shifting conflict resolution to the planning phase.
The Multi-Agent Traffic Jam
Artificial intelligence agents write code fast, but they coordinate poorly. When a swarm of agents edits a codebase, they frequently touch the same files. Standard Git flags a conflict if Agent A adds a function at line 50 and Agent B modifies a variable at line 52. The code is logically sound, but physically collided.
This friction compounds as teams scale their AI workforce. Agents waste expensive compute cycles resolving false positive Git conflicts instead of shipping features. The bottleneck is no longer generation speed. The bottleneck is line-based version control.
Identity Over Geometry
Git uses geometry to merge code. It cares about line numbers and physical proximity. If an agent moves a function to the bottom of the file, and a human modifies its logic at the top, standard Git fails to reconcile the changes.
Weave changes the paradigm from geometry to identity. Using tree-sitter, it parses code into semantic entities like functions, classes, and interfaces. It performs a three-way merge based on a function's name, type, and scope. If the identity matches, Weave merges the logic cleanly, regardless of where the code now lives.
Resolves merge conflicts that Git can't by understanding code structure via tree-sitter.
The Goldilocks Abstraction
Prior attempts to fix Git rely on Abstract Syntax Trees. Tools like mergiraf break code down into atomic AST nodes. This is technically accurate but practically exhausting. When an AST merge fails, it outputs a cryptic tree of node triples that humans cannot quickly decipher.
Weave operates at the entity level. It hits the goldilocks zone of abstraction. By merging whole functions and classes, it remains simple and fast. When a conflict does occur, the output is plain text, clearly stating which function was modified and which was deleted.
The key difference: mergiraf matches individual AST nodes (GumTree + PCS triples). Weave matches entities (functions, classes, methods) as whole units. Simpler, faster, and conflicts are readable
| Feature | Legacy Git | Mergiraf | Weave |
|---|---|---|---|
| Unit of Merge | Lines of text | AST nodes | Functions and classes |
| Conflict Output | Cryptic diff markers | Complex JSON trees | Plain English entity states |
| Move + Edit Support | Fails completely | Works | Works |
| Agent Coordination | None | None | Built-in MCP server |
A Protocol for Agent Coordination
Merging better is only half the solution. The real breakthrough in Weave is preventing conflicts before they happen. It ships with a Model Context Protocol server designed explicitly for agent coordination.
Before an agent writes a single line of code, it can announce its intentions to the shared state. It claims an entity, essentially locking a specific function. Other agents can see this claim and route their work elsewhere. This moves conflict resolution from the merge phase to the planning phase.
The other big gap: weave ships as an MCP server with 14 tools for agent coordination. Agents can claim entities before editing and detect conflicts before they merge. That's the piece mergiraf doesn't have.
