DEV Community

Cover image for Omnigraph: A Versioned Graph Database for Multi-Agent Context
Sh Raj
Sh Raj

Posted on Fully Autonomous

Omnigraph: A Versioned Graph Database for Multi-Agent Context

Omnigraph Studio showing a graph branch review

Official Studio preview from the Omnigraph repository.

A normal database stores application records. A graph database makes relationships first-class. But systems used by teams of long-running agents need another property: one agent should be able to propose a change without silently overwriting another agent's work.

Omnigraph is a Rust graph database designed around typed domain models, hybrid retrieval, and versioned branches. It is an interesting project because it treats an agent's knowledge as durable, shared data that can be reviewed and merged like code.

Why it is trending now

The GitHub Trending Rust snapshot collected on November 16, 2026 at 06:57 UTC placed ModernRelay/omnigraph at number one, with 174 stars gained that day. The repository describes itself as an object-storage-native graph database with branching and a typed ontology.

The release history is active too. The latest stable release is v0.15.0. The November 15 prerelease is v0.15.1-edge+6d92b43, and it documents a storage-format difference from stable. That distinction matters more than the star count if you are evaluating it for production.

This is a new and still-evolving database, not a mature replacement for every graph workload.

Omnigraph Product Hunt listing badge

Launch-listing badge linked from the official project README; it is not a live adoption metric.

The core idea

Omnigraph combines several capabilities in one runtime:

  • Typed ontology: .pg schema files declare node types, edge types, keys, and constraints. Writes are checked against the schema.
  • Hybrid retrieval: graph traversal, vector approximate-nearest-neighbor search, full-text search, and reciprocal-rank fusion can be combined.
  • Branching: agents can write to a task-specific branch, inspect a diff, and merge the result after review.
  • Storage separation: graph data uses the versioned Lance format and can live on local disk or supported S3-compatible object storage.
  • Policy enforcement: Cedar policies are checked server-side on mutations, with authenticated actors and audit tracking.

The branch model is the most interesting design choice. Instead of giving every agent unrestricted write access to a shared graph, create a branch for an ingestion job or task. Review the diff, run checks, then merge. That gives the application a place to validate changes before they become shared knowledge.

Run a small local graph

On macOS or Linux, the official installer downloads release binaries, verifies their SHA-256 checksum, and installs them under ~/.local/bin:

curl -fsSL https://raw.githubusercontent.com/ModernRelay/omnigraph/main/scripts/install.sh | bash
export PATH="$HOME/.local/bin:$PATH"
omnigraph version
Enter fullscreen mode Exit fullscreen mode

Homebrew is also supported:

brew tap ModernRelay/tap
brew install ModernRelay/tap/omnigraph
Enter fullscreen mode Exit fullscreen mode

Create a small schema. The example below stores claims and the sources that support them.

node Source {
  slug: String @key
  title: String
}

node Claim {
  slug: String @key
  statement: String
}

edge Supports: Source -> Claim
Enter fullscreen mode Exit fullscreen mode

Create a query in queries.gq:

query sources_for_claim($claim: String) {
  match {
    $source: Source
    $c: Claim { slug: $claim }
    $source supports $c
  }
  return { $source.title as source }
  order { source asc }
}
Enter fullscreen mode Exit fullscreen mode

Lint the schema and query, then create a local graph:

omnigraph lint --schema schema.pg --query queries.gq
omnigraph init --schema schema.pg graph.omni
Enter fullscreen mode Exit fullscreen mode

Put seed records in seed.jsonl:

{"type":"Claim","data":{"slug":"lower-latency","statement":"The migration reduced request latency."}}
{"type":"Source","data":{"slug":"load-test","title":"Load test report"}}
{"edge":"Supports","from":"load-test","to":"lower-latency"}
Enter fullscreen mode Exit fullscreen mode

Load and query the graph:

omnigraph load --data seed.jsonl --mode merge --target ./graph.omni

omnigraph query sources_for_claim --query queries.gq \
  --params '{"claim":"lower-latency"}' \
  --format table --target ./graph.omni
Enter fullscreen mode Exit fullscreen mode

To make the review model concrete, load another file on a branch, inspect the diff, and merge only after the result is acceptable:

omnigraph load --data more.jsonl --from main --branch review/first-change \
  --mode merge --target ./graph.omni

omnigraph branch diff review/first-change --into main --target ./graph.omni
omnigraph branch merge review/first-change --into main --target ./graph.omni
Enter fullscreen mode Exit fullscreen mode

This is a deliberately small local workflow. The onboarding guide explains how to evolve the schema, add data, and use branches.

Where it fits

Omnigraph is worth evaluating for:

  • A company knowledge graph that connects decisions, documents, people, and evidence.
  • Agent memory where each task can create a branch and request review.
  • A development graph linking issues, pull requests, dependencies, and releases.
  • Research systems where claims need provenance and sources.
  • A retrieval layer that needs relationships and vector or text search together.

The built-in agent skill is also notable. The CLI can export a version-matched skill for Claude Code, while the server exposes an MCP endpoint for agents that need to query or mutate a served graph. The skill and server should be kept in sync with the installed CLI.

Stable versus edge: read this before testing

As of November 16, the latest stable release is v0.15.0. The November 15 edge build reports that it writes storage format 17, while v0.15.0 writes format 16 and serves only through format 16. A graph written by that edge build cannot be opened by v0.15.0.

That is a concrete reason to keep experiments separate. Use a disposable graph or a backup when testing edge builds, and read the release compatibility table before pointing an edge binary at data that stable software must continue to read. Do not assume that a matching HTTP contract means matching on-disk compatibility.

Omnigraph Cloud is in private preview. For a self-hosted cluster, you still need to plan authentication, storage, policies, backups, and upgrades. The local-file quick start is not the same thing as a multi-user production deployment.

How it compares

Option Better fit
Neo4j A mature graph platform with a broad ecosystem and established query workflows
Kuzu Embedded graph queries inside an application or local data workflow
PostgreSQL + pgvector Relational data with vector search when graph traversal is not central
Omnigraph Typed, versioned graph state with branching and hybrid retrieval, especially for agent workflows

The repository is MIT licensed. Its early release stage, changing storage formats, and private-preview cloud offering are real trade-offs. Start with a local graph and one concrete query before deciding whether its cluster model fits your deployment.

Would you let an agent write directly to a shared knowledge graph, or would you require every task to create a reviewable branch? That decision is a good first test of whether Omnigraph's model matches your application.

Sources and further reading


Written by Shaswat Raj Β· LinkedIn Β· StackShade on YouTube

Top comments (0)