omnigraph.dev

A lakehouse graph is a graph dataset and query layer built directly on object storage (the same storage layer a data lakehouse uses) rather than on a dedicated graph database cluster. You get graph structure, typed schemas, and hybrid retrieval, but the durable substrate is object storage such as S3. Omnigraph is one example: it describes itself as an "object-storage native" versioned graph engine with Git-style branch, review, and merge workflows. This architecture fits analytical and agent-context workloads well; it is a weaker fit when you need very low-latency transactional graph queries.

How the lakehouse part changes the graph

In a conventional graph database, storage and compute are bundled: nodes, edges, and indexes live on the database's own disks, and scaling means scaling that cluster. In a lakehouse graph, the durable copy of nodes, edges, embeddings, and metadata sits in object storage, and the engine reads and writes against it.

That shift has concrete consequences:

• Cheap forks. Branching a graph does not require copying a cluster's state. Omnigraph's workflow shows omnigraph branch create as a cheap fork of main.
• Snapshot consistency. Omnigraph commits whole graphs atomically, so readers see a consistent snapshot rather than a partial write.
• Time travel. Every version stays queryable, and a query can be pinned to any snapshot.
• Storage you own. Omnigraph lists "Deploy on infrastructure you own" as a capability, which matters if data residency or existing lakehouse investment is a constraint.

The trade-off is latency. Object storage is not a low-latency random-access medium, so a lakehouse graph is better suited to batch ingestion, analytical retrieval, and assembling context for agents than to high-QPS transactional graph lookups.

What the graph layer adds beyond files

A pile of Parquet files on S3 is not a graph. The engine supplies the parts that make it one.

Hybrid retrieval in a single query

Omnigraph fuses vector similarity, full-text search, and graph structure in one query using reciprocal rank fusion (rrf()). Its documented example ranks people by embedding similarity, bio text match, and graph position simultaneously:

query find_experts($topic: String) {
  match { $p: Person }
  return { $p.name, $p.role }
  order { rrf(nearest($p.embedding, $topic), bm25($p.bio, $topic)) }
  limit 5
}

The point for a lakehouse graph is that the retrieval logic is a file—linted, versioned, reviewed—not an ad-hoc script against exported data.

Typed schema enforced at write time

Writes are typed and checked, and malformed writes are rejected at the branch before they land. In a lakehouse context this is the difference between a governed graph and a folder of loosely validated extracts.

Merge semantics that are not last-write-wins

Omnigraph performs row-level three-way merges with typed conflicts, and attributes each merge to its author. That is a meaningfully stronger guarantee than overwriting a partition.

Why branching matters for multi-agent writes

The core problem a lakehouse graph solves for agents is concurrent writes. If several agents ingest, deduplicate, and link data into the same graph, direct writes to a shared main branch collide.

Omnigraph's documented workflow is a four-step loop:

1. Branch. Two agents, Claude Code and Hermes, each fork main into their own branch (omnigraph branch create).
2. Write. Hermes adds nodes and edges while Claude Code dedupes existing records; isolated branches do not collide, and schema and policy are enforced on each (omnigraph mutate).
3. Review. Each branch's diff is approved by a human or another agent (omnigraph diff).
4. Merge. Both land on main in review order, three-way and attributed to their agent (omnigraph branch merge).

No agent writes to main directly. The schema rejects malformed writes at the branch, policy decides who may merge, and the commit graph records every change and its author. Destructive changes require explicit approval before they apply.

When a lakehouse graph is the right choice

Use this evaluation checklist against your own workload:

Choose a lakehouse graph when your graph is large, analytical, or agent-facing; when multiple agents or pipelines write concurrently; and when you want versioning, review, and audit as first-class features.

Choose a conventional graph database when your workload is low-latency transactional traversal at high query rates, or when your team has no object-storage lakehouse to build on.

Practical caveats

Omnigraph Cloud is listed as a private preview with a waitlist, so availability and terms should be confirmed directly rather than assumed. The page does not state pricing, so do not treat the engine as free or login-free without checking. The project is open source (GitHub, 1.6k stars per the page), and the CLI reference is the place to verify exact command behavior before designing a pipeline around it.

A graph engine is the software layer that stores, queries, and enforces rules over graph-structured data—nodes, edges, and their properties. A versioned graph engine adds Git-style branching, review, and merge on top of that, so multiple agents can write to the same graph without colliding. Omnigraph is one example: it is described as a versioned graph database on object storage, built for context assembly, where agents work with graph data the way engineers work with code—branched, typed, reviewed, merged, audited, and governed. This explanation fits teams building agent memory or context systems that need concurrent writes, traceable history, and retrieval that combines more than one search method.

Graph engine vs. traditional graph database

The core job is similar: model relationships as nodes and edges and answer traversal queries. The difference is where control lives.

The practical consequence: a traditional database asks "is this write valid right now?" A versioned engine asks "is this branch's diff valid, reviewed, and mergeable?" That second question is what makes multi-agent writes tractable.

How branch-and-merge works for concurrent agents

Omnigraph's documented workflow has four steps, and no agent touches main directly.

1. Branch. Each agent forks main into its own branch (omnigraph branch create). Forks are described as cheap.
2. Write. The agent mutates its branch (omnigraph mutate). Schema and policy are enforced at the branch, so malformed writes are rejected before they land. Isolated branches never collide—in the documented example, one agent adds nodes and edges while another dedupes existing records.
3. Review. The branch diff (omnigraph diff) is approved by a human or another agent.
4. Merge. Branches land on main in review order via three-way merge (omnigraph branch merge), attributed to their agent.

Two properties matter here. First, merges are row-level with typed conflicts rather than last-write-wins, so a conflict surfaces as a structured problem instead of silent data loss. Second, the commit graph records every change and its author, which turns "which agent wrote this?" into a query rather than an investigation.

Where this breaks down: if your workload is a single writer or a small team editing sequentially, branching adds ceremony without much payoff. The model earns its keep when several agents or pipelines write to the same graph at once.

Hybrid retrieval: one query, three signals

A common failure mode in agent memory is retrieval that relies on a single method. Vector similarity finds semantically close items but misses exact names; full-text search finds exact terms but misses paraphrase; graph traversal finds structurally related items but ignores content. Omnigraph's answer is to fuse all three in a single query with rrf() (reciprocal rank fusion).

The documented example is a find_experts query that ranks people by vector similarity on embeddings, BM25 on bios, and graph structure simultaneously, returning one fused ranked list:

query find_experts($topic: String) {
  match { $p: Person }
  return { $p.name, $p.role }
  order { rrf(nearest($p.embedding, $topic), bm25($p.bio, $topic)) }
  limit 5
}

Two design details are worth noting. Each "lens" on the graph is itself a file—linted, typed, versioned, and reviewed like code—so retrieval logic gets the same review process as data. And because queries can pin to any snapshot, you can reproduce what an agent saw at a given version, which is useful when debugging why a retrieval returned the wrong context.

Safety properties for agent writes

The engine's documented safeguards map to specific failure modes:

• Typed schema — writes are checked and rejected at the branch, so bad data never reaches main.
• Atomic whole-graph commits — readers see a consistent snapshot, never a partial write.
• Approval-gated operations — destructive changes require explicit approval before apply runs.
• Policy-controlled merges — the policy, not the agent, decides who can merge.
• Time travel — every version stays queryable, so you can audit or replay against any past state.

Together these shift the trust model: you don't have to trust each agent to write correctly, because the engine and the review step stand between the agent and shared state.

Deployment and availability

Omnigraph is described as object-storage native (the keywords reference Lance on S3) and deployable on infrastructure you own. Omnigraph Cloud is listed as a private preview starting early October, with an email waitlist. The source material does not state pricing, so cost and access terms should be confirmed directly rather than assumed. The project lists 1.6k GitHub stars and publishes docs and a CLI reference.

Choosing whether this model fits

Consider a versioned, object-storage-native graph engine when:

• Multiple agents or pipelines write to shared graph data concurrently.
• You need an auditable record of who changed what, and the ability to query past snapshots.
• Retrieval quality depends on combining semantic, lexical, and structural signals.
• You want schema and policy enforced by the engine rather than by application code.

A conventional graph database remains the simpler choice when writes are serialized, history requirements are light, and a single retrieval method is sufficient. The deciding question is concurrency: the more independent writers you have, the more the branch-review-merge model pays for itself.

A branchable graph is a versioned graph database in which each writer—an agent, a pipeline, or a person—forks its own branch from a shared main graph, makes changes in isolation, and merges back only after review. It applies when multiple agents write to the same graph concurrently and you need to prevent collisions, reject malformed writes before they land, and keep an auditable record of who changed what. Omnigraph describes this model as "graph as code," with Git-style branch, version, and merge for data.

The core problem it solves

When several agents work on one graph at once, uncoordinated writes collide: two agents may edit the same node, one may add a duplicate that another is already deduplicating, or a malformed write may corrupt shared state before anyone notices. A branchable graph isolates each writer's work until it is reviewed, so concurrent batch writes stay safe and no agent touches main directly.

The fork–write–review–merge cycle

Omnigraph's documented workflow uses two agents, Claude Code and Hermes, working on the same graph:

1. Branch. Each agent forks main into its own branch (for example, claude/dedupe and hermes/ingest). Forking is cheap: omnigraph branch create.
2. Write. Hermes adds new nodes and edges while Claude Code dedupes existing records. Because branches are isolated, the two never collide, and the schema plus policy are enforced on every write (omnigraph mutate).
3. Review. Each branch's diff is approved by a human or another agent before it lands (omnigraph diff).
4. Merge. Both branches land on main in review order, via a three-way merge attributed to the agent that made the change (omnigraph branch merge).

The result is two agents, one graph, no collisions.

What the engine enforces

Branching alone is not enough; the guarantees come from what the engine checks at each stage:

• Typed schema. Writes are typed and checked, and malformed writes are rejected at the branch before they land.
• Policy-gated merges. The policy decides who can merge, so approval is a rule rather than a convention. Destructive changes require explicit approval before they apply.
• Three-way, row-level merge. Conflicts are typed and resolved at row level rather than by last-write-wins.
• Attribution and audit. The commit graph records every change and its author, so history shows which agent produced which edit.

Consistency and history

Two related capabilities make branched work practical:

• Atomic whole-graph commits. Readers see a consistent snapshot and never a partial write, so a query never observes a half-merged branch.
• Time travel. Every version stays queryable, and a query can be pinned to any snapshot—useful for reproducing what an agent saw when it made a decision.

When branching is the right fit

Branching pays off when writes are concurrent, changes need review before they affect shared data, or you need to trace each change to its author. For a single writer making small, trusted updates, the branch-review-merge cycle adds steps without adding safety. The model assumes writers can be identified and that someone—human or agent—can approve merges; if neither holds, policy-gated merging has nothing to enforce.

Context assembly is the process of gathering, structuring, and serving the right data to an AI agent at query time. A graph engine supports it by storing relationships as first-class data, then combining vector similarity, full-text search, and graph traversal into a single ranked result. This approach fits teams running multiple agents over shared, changing data who need typed writes, versioned snapshots, and reviewable changes rather than ad hoc retrieval stitched together per prompt.

Why agents need structured context, not just retrieval

A retrieval pipeline that returns a flat list of text chunks gives an agent fragments without relationships. Context assembly asks a different question: which entities matter, how are they connected, and what is the current, consistent state of that information?

That distinction matters when agents write as well as read. If several agents mutate the same store concurrently, last-write-wins behavior can silently corrupt context. A graph engine designed for assembly treats the context layer like code: typed, versioned, reviewed, and merged.

How hybrid retrieval assembles a single answer

Omnigraph's documentation describes each "lens" on the graph as a typed, linted query file. A lens can fuse multiple retrieval signals in one pass. The example query find_experts ranks people by vector similarity, full-text match, and graph structure simultaneously, combining them with reciprocal rank fusion (rrf()):

query find_experts($topic: String) {
  match { $p: Person }
  return { $p.name, $p.role }
  order { rrf(nearest($p.embedding, $topic), bm25($p.bio, $topic)) }
  limit 5
}

Three properties make this useful for context assembly:

• One query, multiple signals. Vector, full-text, and traversal results are fused rather than concatenated, so ranking reflects all three.
• The lens is a file. It can be linted, versioned, and reviewed like any other code artifact.
• Typed schema enforcement. Writes are checked against the schema and rejected at the branch before they land.

Keeping concurrent agent writes safe

When many agents work on the same graph, isolation becomes the core problem. Omnigraph uses Git-style branching: each agent forks main, writes on its own branch, and merges only through review.

The documented workflow has four steps:

1. Branch — an agent creates a branch from main (omnigraph branch create).
2. Write — the agent adds nodes and edges on its isolated branch (omnigraph mutate); schema and policy are enforced at write time.
3. Review — a human or another agent inspects the diff (omnigraph diff) before it lands.
4. Merge — approved changes land on main in review order via three-way merge, attributed to the authoring agent (omnigraph branch merge).

No agent writes to main directly. The schema rejects malformed writes at the branch, policy decides who may merge, and the commit graph records every change and its author.

Practical properties for agent context

When this approach fits

Choose a versioned graph engine for context assembly when agents share mutable data, when auditability matters, or when retrieval quality depends on relationships rather than text similarity alone. A simpler vector store may suffice for read-only, single-agent retrieval over static documents.

Omnigraph Cloud is listed as a private preview opening in early October, with a waitlist; the project is also open source (GitHub, 1.6k stars) and documented for deployment on infrastructure you own.

Omnigraph is a versioned graph database built on object storage, designed for context assembly and agent memory. Its distinguishing idea is that graph data is treated like code: schema, queries, policies, and infrastructure are declarative files that are branched, reviewed, merged, and audited. It fits teams running multiple agents against shared graph data who need isolation, typed writes, and a reviewable history — and it is less suited to simple single-writer graph lookups where a conventional graph database is enough.

The core model: graph as code

In Omnigraph, the pieces that define how a graph behaves are files rather than dashboard settings:

• Schema — node and edge types, enforced by the engine.
• Context and queries — each "lens" on the graph is a typed, linted query file.
• Policies — rules governing who can write and who can merge.
• UI and infrastructure — also declarative.

Because these are versioned like code, a change to how the graph is queried or written goes through the same review path as a code change. The engine enforces the schema, so malformed writes are rejected at the branch before they reach main.

Git-style workflows for concurrent agents

The central workflow is branch-per-agent. The documented example shows two agents, Claude Code and Hermes, each forking main:

1. Branch — each agent creates its own cheap fork (omnigraph branch create).
2. Write — Hermes adds nodes and edges while Claude Code dedupes existing records; isolated branches never collide, and schema and policy are enforced on each.
3. Review — each branch's diff is approved by a human or another agent (omnigraph diff).
4. Merge — branches land on main in review order via three-way merge, attributed to their agent (omnigraph branch merge).

No agent writes to main directly. The commit graph records every change and its author, which is what makes the history auditable rather than just logged.

Key capabilities and what they mean in practice

A concrete example of the retrieval model: a find_experts query takes a topic string, matches Person nodes, and orders results by rrf(nearest($p.embedding, $topic), bm25($p.bio, $topic)) — combining embedding similarity and keyword relevance in a single ranked list. The whole lens is one file that can be linted, versioned, and reviewed like any other code.

Deployment and availability

Omnigraph is object-storage native — the page describes it as a "Lance S3 graph" — and is positioned to deploy on infrastructure you own. A hosted option, Omnigraph Cloud, is listed as a private preview starting in early October, with a waitlist signup. The source material does not state pricing, so cost and access terms for either deployment path should be confirmed directly rather than assumed.

When Omnigraph fits — and when it doesn't

It fits if:

• Multiple agents or batch jobs write to the same graph concurrently and you need branch isolation and review before merge.
• You want schema enforcement and an auditable, attributable history of every change.
• Your retrieval needs mix vector, keyword, and graph-structure signals in one query.
• You need to pin queries to past snapshots for debugging or compliance-style review.
• You want to run on your own object storage rather than a managed graph service.

A conventional graph database may be the better choice if:

• You have a single writer or low-concurrency workload where branching adds process without benefit.
• Your team doesn't want a code-review workflow around data changes.
• You need a mature managed service with published pricing today — Omnigraph Cloud is still in private preview per the source.

The practical test is whether your pain is coordination — agents colliding, untraceable changes, inconsistent reads during ingestion. If so, Omnigraph's branch-diff-merge model addresses exactly that. If your pain is simply query performance on a stable graph, the versioning machinery is overhead you may not need.