One platform for your data, models, agents, extensions & integrations · self-hosted, sovereign, CPU-native

The universal operating
system for intelligence.

One platform where your data, models, agents, extensions, and integrations all run on a single copy on disk, self-hosted on your own hardware. Every data domain is unified at the data layer, not stitched together at the query layer — so every model, agent, and extension works against the same store, with nothing to sync.

Ten products, ten copies, ten licences, kept in sync by hand. Now one store.

Underneath, it is one sovereign, CPU-native substrate: the same store presented through ten familiar database faces, all reading that one copy on disk.

Graph, SQL, key-value, document, search, vector, OLAP, time-series, streaming, and object storage are all faces of a single store, reading one copy of the data on disk. You run it on your own hardware. A single node is free, with no time limit.

Built for teams that cannot ship data out: air-gapped and classified networks, financial-crime investigation, regulated on-prem.

Download the free node See the benchmark board

Ten products, ten copies, kept in sync by hand — collapsed into one store that holds a single copy, read ten familiar ways.

The crown

Follow a graph bigger than memory, hundreds of levels deep, where other engines stop.

Point Semurg at a graph far larger than the machine's RAM and it keeps following relationships hundreds of levels deep while holding well under a gigabyte of memory. In-memory engines run out; recursive queries in mainstream databases give out after a handful of hops. This is survive-versus-stop, not a tuning ratio, and it is the one fact no competitor can argue away.

Survive-versus-stop: where other engines run out, Semurg keeps going. Same question, further than your current tool can reach.

See it survive where others stop Then install a node Live

The idea

What it is, in one read.

Today you run a different product for each workload. A graph database here, a search engine there, a warehouse, a cache. Each one keeps its own copy of your data, its own operations, and its own license. That is N products, N copies, N licenses. Semurg is one store instead.

One store, not ten systems.

Every record lives in one compact, uniform container in a single on-disk store. Disk is the source of truth. RAM is a pipe, not a second copy.

Ten paradigms, one copy.

Graph, SQL, search, and the rest are views over the same containers. No separate products, no ETL between them, no second copy to keep in sync.

It resonates with your hardware.

On install it fans out across your physical cores, spreads across your disks, and loads the build tuned to your CPU.

Not ten databases wired together. Ten ways to read one store.

How to read the honesty tags below

Livemeasured and shipping today; reproduce it yourself. Buildingreal foundations in place, the finished path in active development. Roadmapdesigned and specified, not yet built. Named so you can plan. We concedea place a specialist tool wins today. Disclosed on purpose.

Benchmark numbers live on data.semurg.io, equal-answer verified and published with a kit you run yourself. This page states capabilities and our own reproducible facts.

The ten faces

Same store. Same copy. Ten ways to read it.

Not ten equal products. Some are shipped query surfaces today, the rest are expressed as scan patterns over the same store. We tag each one honestly.

Two-way by design: whatever you load, you can read back as any face — and export back out losslessly. One copy in the middle, no copies on the sides.

graphTraverse relationships and run deep k-hop queries.shipped

key-valuePoint get and put by key.shipped

searchPredicate scan at bandwidth. Not BM25 ranking.shipped

objectRead the raw bytes of large values.shipped

OLAPGroup-by and aggregate over column scans.shipped

SQLRelational reads as a batch point-read pattern.scan pattern

documentRecord plus its embedded neighbors, kept together.scan pattern

time-seriesOrdered ranges as a range scan.scan pattern

streamingTail and replay the append log.scan pattern

vectorExact search over compact binary codes; recall published honestly. Approximate ANN conceded to specialists.scan pattern

shipped a first-class query surface you can call today scan pattern the shared scan or fold, framed as that paradigm in build approximate ANN at scale, on top of the exact search over compact binary codes that runs today

One binary perimeter. The data is never exported to move between faces.

Where we don't win

The honest edges of one store.

One store is a real advantage for reads over related data kept together. It is not a claim to beat every specialist at its own game, so here is where a dedicated system is the right tool. Disclosing this is the point, not an apology: a limit you can read cannot be used against you.

Ranked full-text search. BM25 relevance over a large text corpus is a dedicated search engine's home turf. We scan and match at bandwidth; we do not rank like a search engine, yet.

Billion-scale approximate nearest-neighbour. A dedicated vector database's specialty. We run exact search over compact binary codes today, with recall@k published honestly (recall@1 perfect, recall@k lower); approximate ANN at scale is conceded to the specialist indexes.

Multi-statement transactions. We are single-writer with atomic batch appends and read-committed reads today. Full multi-statement isolation is a named build.

Streaming consumer-groups and replay, and key-value counters, TTL, and compare-and-set. We do high-rate append and point reads; the consumer semantics and KV atomics are on the roadmap.

A hardened multi-node cluster and its network transport. In development; not exposed until the secure-join hardening lands. We do not call anything unhackable.

The ten faces are not all equal. Five are shipped query surfaces you can call today (graph, key-value, search, object, OLAP). Five are expressed as scan patterns over the same store (SQL, document, time-series, streaming, and vector, an index-free exact search over compact binary codes exercised through the demo face rather than a callable JSON op). None of these limits sits on the read-mostly analytical path where the wins above hold.

Same claim on the docs page and the collapse wall, with the tier of every face.

Use cases

What people build on one copy.

Each of these normally means several databases and the pipelines that keep them in sync. On Semurg they are one store. Ordered live-first, and tagged honestly.

Deep-network investigationLive

Follow beneficial ownership and money flow hundreds of links deep across a graph far bigger than memory, on one machine, whole history in one place. No hop cap, no re-load, no batch rebuild. Panama Papers, but live, and past where your tool gives out.

Replaces a graph DB plus the out-of-memory workarounds and sampling around it.

Sovereign quant & market-data stackBuilding

One substrate holds live ticks, deep history, and the analytics over them, streamed from disk instead of held entirely in memory. As-of joins, rolling aggregations, and read-while-writing on one copy, on-premise, priced per node. We concede raw single-scan latency to in-memory specialists; the wins are out-of-core capacity and stack collapse.

Replaces the real-time-tier / historical-store / cold-archive pipeline and its per-core licences.

GraphRAG on one copyBuilding

Chunks, embeddings, entities, and relationships live as containers kept together on one copy. A search seeds a short graph walk that fetches the exact passages, all in one process. Change a fact and the very next answer reflects it, with no re-index window. Our defensible claim is consistency-under-update, not vector-search latency.

Replaces vector DB plus graph DB plus chunk store plus reranker plus the sync-ETL between them.

Regulated-AI gatewayBuilding

A perimeter that keeps data on-premise and, when a request must reach an external model, removes personal fields on the way out and restores them on the way back, so the outside service never sees regulated data. A governance and PII wedge today, with the fuller pipeline on the roadmap.

Replaces manual redaction, blocked projects, and the "we cannot use AI on this data" exceptions.

Sovereign CPU model servingBuilding

Stream model weights from disk through the same substrate that serves your data, on commodity CPUs you already own. Models too large for memory stream in; shared expert weights are stored once; the model sits beside the knowledge it reasons over. A sovereignty-and-economics capability, not a speed record. We concede raw single-stream latency to GPUs.

Replaces a separate GPU model server and its weight store, for the sovereign, on-premise case.

Consolidate the specialty databasesLive

Present the many faces from one copy. Analytical relational queries, columnar aggregations, time-series ranges and rollups, key-value batches, and document aggregations all run on the same substrate, on-premise, in-application, priced per node. Measured equal-answer and published with a reproduce-it-yourself kit. The specialist micro-features we do not yet match are named plainly in the honest edges above.

Replaces the analytical half of the estate and the ETL that synced it.

Air-gapped analyticsLive

The whole engine is one binary on one node, behind your firewall. Nothing phones home, so classified and regulated environments get the full engine with no external services and no data egress.

Replaces a hosted analytics stack you are not allowed to send your data to.

Numbers for these workloads live on data.semurg.io, the reproducible board →

Industries

Who it's for.

Sequenced the way we actually enter them: led by where the founders have direct credibility and the product is already unbeatable, honest about which is a running capability versus a direction.

Finance: financial crime & AMLDeep-graph plus out-of-core plus sovereign-PII, the exact intersection where mainstream tools cannot follow. The most public, most reproducible proof we have. Live for the deep-network capability; fraud scoring is roadmap.

Finance: capital markets & quantDeep history out-of-core instead of expensive memory, read-while-writing on one copy, on-premise, priced per node. Entered on the research and backtest tier. Building toward a public head-to-head; honest about conceding raw latency to in-memory specialists.

Banking, wealth, super & regulatorsThe same deep-network and sovereignty problems one desk over, expanding into the adjacent faces the account was already paying separate vendors for. Live where it is deep-graph and analytical; roadmap where it is fraud or streaming.

Regulated, document-heavy orgs (legal, compliance)Grounded answers over a private corpus, consistent on one copy, on-premise, with provenance. Building: retrieval and consistency are live; the combined driver and generation are in development.

Government & sovereign intelligenceAir-gapped, on-premise, out-of-core knowledge at scale, with the model on your own hardware. Roadmap and positioning; the honest KG claim is no per-item curation, not full automation.

Healthcare & life sciencesThe most regulated data you hold, and it cannot go to a cloud model. One-copy, on-premise, on-CPU is how you use AI without moving the data. Roadmap; entered through the PII and sovereignty wedge first.

Defence & national securityEmbedded, on-premise, air-gapped-capable, no egress, CPU-native inference: the whole design matches the requirement. Roadmap and design engagement.

Enterprise data platformsCollapse a stack of specialized databases and their pipelines into one substrate: one copy, one licence, one thing to operate. A distribution route for whichever vertical wins first.

See the head-to-heads and the full board on data.semurg.io →

Sovereign

Your keys, your box, your data.

Self-hosted end to end, on your hardware and your network. Air-gap it if you want to. Nothing about your data leaves the hardware you put it on.

Everything runs inside your perimeter — data, models, and apps on one copy. Air-gap it and it still works; nothing phones home, nothing crosses the line.

Air-gap if you want it. Runs fully offline, no network dependency at any point.

No cloud account. No sign-up, no phone-home, no per-seat metering.

You own the box. The store lives on your disks and answers from your CPU.

Disk is the source of truth, and the free node runs the complete engine: full writes, no row cap, no time limit. Acknowledged writes survive a process crash (tested with kill -9), and a power cut on a power-loss-protected drive. What a single node does not survive is losing the machine or its disk. Run it behind your own perimeter. How durability and access work →

Install

Download, verify, run on a fresh Ubuntu box.

One command does it on a fresh Ubuntu 24.04 box: it downloads, verifies the checksum, and runs, still under a minute. Prefer to check the checksum by hand? The three manual steps are just below.

curl -fsSL https://one.semurg.io/install | sudo bash

Or the three manual steps

curl -fsSLO https://one.semurg.io/dl/semurg-r11-installer.tar.gz

curl -fsSLO https://one.semurg.io/dl/SHA256SUMS && sha256sum -c SHA256SUMS

tar xzf semurg-r11-installer.tar.gz && cd semurg_installer && sudo ./semurg-install.sh

It is a plain shell script. Read it first: less semurg_installer/semurg-install.sh. It creates /etc/semurg, installs a systemd service, detects your cores and disks, and starts the node. No network calls except the data you pull.

The manual step 2 (and the one-command) print semurg-r11-installer.tar.gz: OK. Expected SHA256
d38d5bbc44b099e9e988a72f310a72f6e9b72f1666c47825b440ec23999a56e5

Verify this download and read the box's live self-attestation →

Reads your hardware. It fans out across your cores, spreads across your disks, and loads the build tuned to your CPU.

Nothing else to install. No compiler and no separate language runtime to install. The release bundles everything it needs.

Serving in under a minute. One command from a downloaded tarball to a running node.

A single node is free and complete. Full writes, no row cap, no time limit, no feature gates. A cluster is a paid licence.

Ubuntu 24.04 (glibc 2.38+)·x86_64·4+ cores·8 GB+ RAM·20 GB+ free disk·2+ NVMe recommended (it stripes across them)

Prefer Docker? Load and run, no sudo. On any x86_64 machine with Docker installed, this downloads a tiny bundle plus the prebuilt image, verifies both, loads the image, and brings up an armed node. Nothing is pulled from a registry and nothing is built on your machine. The compose file already supplies the three container settings the fast disk path needs, so you never type a docker flag:

curl -fsSLO https://one.semurg.io/dl/semurg-docker.tar.gz && curl -fsSLO https://one.semurg.io/dl/semurg-substrate-r11-amd64.tar.gz && curl -fsSL https://one.semurg.io/dl/SHA256SUMS | grep -E ' (semurg-docker\.tar\.gz|semurg-substrate-r11-amd64\.tar\.gz)$' | sha256sum -c - && tar xzf semurg-docker.tar.gz && docker load -i semurg-substrate-r11-amd64.tar.gz && cd semurg-docker && docker compose up

Leave it running and wait for the green line ARMED: cold-op self-test PASSED, then open http://127.0.0.1:4100 in your browser. The first run downloads the image (about two minutes on a normal connection); after that it starts in seconds. No build, no registry pull. If a red SEMURG CANNOT START box ever appears, it names the one flag to add and prints the exact command to paste. Flag-by-flag detail is on the Troubleshooting page.

Windows: run this inside WSL2 (Ubuntu), not PowerShell or CMD — curl, sha256sum, tar and && are Linux/bash. ARM / Apple Silicon: not supported (an Intel Mac is fine). On those, use a cloud x86_64 Linux VM.

No signup. No email wall.

Enterprise clusters

Run Semurg across your fleet.

A single node is free, forever. The multi-node mesh, scaling across your disks, cores, and sites, runs on an enterprise licence. Built for regulated, on-premise, air-gapped enterprise. Independently benchmarked. In active deployment discussions across legal and utilities. We are onboarding a limited group of enterprise design partners for cluster deployments.

The whole pitch, in one line

One store. Your data, your models, your agents. Nothing leaves the building.

Semurg is the sovereign, CPU-native, one-copy substrate where your data, your models, and your agents are faces of a single physical store, on-premise. It collapses the sprawling data-and-AI stack, and the pipelines that glue it together, into one streaming plane you can run and reproduce yourself. That is the definitive data tier for the autonomous era, and it starts as one node on your own box.

Download a node Start here Reproduce the numbers

Download a node. Run it on your own data. Watch it survive where your tools stop. That is the only pitch that cannot be argued away.

Go deeper

Want the long version?

Start here Plain-language walkthrough: download to your first answer in five minutes → Troubleshooting and FAQ Real problems, plain fixes, and the container flags → One store, ten reads All ten faces answer against one store, side by side → The measured board Every metric and head-to-head, methodology and raw output, reproduce it on your box → Per-paradigm pages How each face is expressed against the one store → Docs Install, operate, and query →

The universal operatingsystem for intelligence.