Video yükleniyor...
Video Yüklenemedi
Every AI company I've talked to is solving the same problem: How to let several agents write to the same data without one silently undoing another's work? Omnigraph is an open-source graph database that versions data the way developers already version code: ↳ Each agent writes on its own... show more
16,277 görüntüleme • 4 gün önce •via X (Twitter)
23 Yorum

Is this doing the same thing as graphify does for multi harness dev work?

A smart solution to prevent AI agents from overwriting each other's work. Branching makes collaboration safer and more reliable.

Concurrent writes are the hidden cost of multi-agent setups. The boring fix works: each agent on its own branch, one reviewer merges. Nothing gets silently undone.

Your two agents touched different fields on the same node, so that merge is clean either way. The harder case is two edits that are both valid against main and wrong sitting next to each other. Does the policy catch that one?

The Git model maps pretty cleanly here. The part that usually bites isn’t two agents hitting the same node at the exact same second, it’s them having worked on overlapping parts for a few minutes and both trying to land. Curious how the conflict signal looks to the agent over MCP: does it get enough context to actually reason about the overlap, or is it mostly “retry on latest”? Once the graph gets bigger and the changes are less local, that difference starts to matter.

I’d want the “why” saved alongside each agent’s diff. Knowing what the other agent was trying to preserve could make a merge much less guessy.

Hit this with two agents editing one config file. Now every write carries the version it read, and a mismatch sends it back to reread.

Silent overwrites are the worst kind of bug because nothing breaks, the data is just quietly wrong. Versioning data like code makes a lot of sense. When two agents really conflict, does a human pick the winner?

when two agents change the same node on different branches, who settles it at merge, a person or the policy?

is better than graphiti from zep ?

Really like this approach. Giving each agent its own branch and checking merges against the latest main makes shared changes easier to review. Thanks for sharing the demo!

Versioning helps, but your agents still need one writer at a time.

Branching beats row locks for agents

What happens at merge time if one agent deletes a node and another adds an edge to it? I’d want to see that conflict before either change lands.

Branches catch the conflict after the fact. The other half is agents telling each other what they're about to touch. In Naetive, agents message each other directly, so one can check with another before they both change the same thing.

Branch per agent makes sense. Silent overwrites are worse than crashes because nobody notices until something’s gone

cool asf

Flagging the conflict instead of silently overwriting is key

Looks like glorified worktrees. Claude is actually very good at them natively, with a few good, simple skills. I managed 10s of "feature projects" at once and have a master Claude coordinating everyone. Not that complicated.

Hits all notes

versioning agent data like git code is such an obvious fix it’s wild it took this long.

The branch-per-agent idea fits office data too, not just code. In small-business automation, I already keep AI-extracted values out of the master sheet until a person checks them. Curious how Omnigraph shows it when two branches edit the same node at merge time.

versioning agent writes like a git history is the only way that shared state doesn't get wrecked
