Models and datasets

Models and datasets, prepared once into Semurg's on-disk form.

Big language models and large public datasets are the slow, heavy part. We do that work once: we turn them into Semurg's own fast on-disk form so your node reads them directly, with no convert step and no import on your side. Delivery is license-gated and inside your control, and each package verifies itself as it lands. Nothing about your own data ever leaves your node.

The intelligence surface is the canonical home for how models run on Semurg: intelligence.semurg.io. It states plainly what is serving today and what is still building. This page is the catalogue of what you can bring in, tagged honestly, part by part.

Gemma 4 E4B
Model: small local, plain text
Qwen3
Model: roadmap, not yet live
Kimi K3
Model: frontier-scale research proof, parked
Public graphs
Dataset: Wikidata, OpenStreetMap
How it works
The delivery, in plain words

New to Semurg? → Start here, get a node running first. This page is the world you bring into it.

How delivery works

Transform once. Deliver to your node.

No jargon. Here is the whole idea in seven plain steps.

1
Your node reads packages directly.
When you download and install Semurg, the node on your own machine can pull a prepared package and read it in place. It stays on your hardware; your own data never leaves it.
2
The hard part is already done.
Our genesis cluster has taken large models and real datasets from the outside world and turned them, once, into Semurg's own fast on-disk form.
3
You stream, you do not convert.
Your peer pulls a package straight in. There is no import and no conversion step on your side. It arrives ready to read.
4
It checks itself for free, as it lands.
Every package carries its own fingerprint. Your node confirms each piece is exactly right while it arrives, so a corrupt or tampered byte cannot slip through. There is nothing extra to run.
5
It skips what you already have.
If two packages share pieces, or you already hold part of one, your node only pulls the difference. Nothing is downloaded twice.
6
It survives interruptions.
If the connection drops or the machine is pulled mid-transfer, it picks up where it left off, not from zero.
7
Mirrors stay inside your control.
Within your own estate or an authorized network, a node that already holds a package can serve it to the next one, so a large rollout does not funnel through one server. This is license-gated and inside your control, not an open public network.
Access is your key. Packages are license-gated. A node only serves what your key allows, so distribution stays inside your control. Nothing about your own data is ever sent anywhere; only the prepared, public model and dataset packages move, and only under your licence.
Category 1 of 2 · Models

Models.

A model is something you run to generate: give it a prompt and it produces text and answers. These stream in and run on your own CPU, with no graphics card needed. Each card says plainly what it is, roughly how big it is, and what your machine needs.

Local model · the honest current state

Gemma 4 E4B

A compact open model that writes and answers in plain, coherent text, on your own CPUs with no graphics card. Today it answers via a managed local sidecar on the node; native collapse of the weights into the one substrate is in development. The point is sovereignty and economics, the model on hardware you own with nothing leaving the building, not a speed record: a GPU still wins raw single-stream latency, and we say so.
Rough sizea few gigabytes on disk
Your machine4+ cores, 8 GB RAM, CPU only
Statusanswers on CPU today (managed sidecar); native weight-collapse building
How it serves → Local · on CPU today
Canonical status on intelligence.semurg.io. One-click package delivery into the substrate is being wired; until then, sovereign CPU serving is via the managed sidecar.
Roadmap model

Qwen3

A capable open model family we plan to bring onto Semurg next, alongside Gemma 4 E4B. It is not available to stream yet. When the one-time transform lands, your node pulls it the same way as the others, CPU only, checked for free on arrival, deduped and resumable. We list it here so the roadmap is honest, not to claim it is live.
Statusroadmap, not yet transformed or streamable
Your machineCPU only, sized to the variant you choose
The ruletransform once, then it is streamable to all peers
See what is coming → Roadmap
Planned, not live. This card shows intent; it is not a stream button yet.
Frontier-scale research proof, parked

Kimi K3

The largest open model there is, 2.8 trillion parameters, far larger than any single machine's memory. We have demonstrated a single CPU node holding and running a model of this scale straight from disk, as a research proof that the substrate's streaming works at frontier scale. It is parked on specific hardware and is not a product you stream or demo today. What it proves: if one node can hold the biggest open model, it can hold anything you bring it, model or data, on the same shelf.
Shape2.8 trillion parameters, 16 of 896 experts active per token
Rough sizeroughly 1.5 TB, held on disk, not in RAM
Your machinea large research node, many cores, fast NVMe disks, CPU only
Statusresearch proof, parked on specific hardware, not streamable today
See what is coming → Research, parked
A demonstrated research capability, not a live stream. Frontier-scale serving is parked pending target hardware.
More models on the way

Your models and extensions

The shelf grows. Models we evolve on Semurg itself, and models the community builds, arrive the same way: transformed once, then streamable to every peer, with the same free check and the same skip-what-you-have.
Statusin progress, added over time
The ruletransformed once, then it is streamable to all
See what is coming → Growing
Category 2 of 2 · Datasets

Datasets.

A dataset is not a program, it is data you explore: real records you load, see as a live graph, and query. A model generates; a dataset is what you look at and traverse. Same streaming, same free check on arrival.

Large public graph

Wikidata

The open knowledge graph seen as entities and the relationships between them: roughly 100 million entities and over a billion statements, a real graph you explore and traverse. Genuinely larger than memory, so it is the dataset that shows the out-of-core deep traversal surviving where in-memory engines stop.
Rough sizea slice is tens of megabytes, the full graph is well over a hundred gigabytes
Your machinemodest for a slice, plenty of disk for the whole graph
Good fordeep graph exploration, knowledge-graph queries, out-of-core traversal
See what is coming → One-click stream: roadmap
Loadable today via the reproducible kit on data.semurg.io; the one-click peer stream is being wired.
More datasets on the way

Other public datasets

Wikidata is the flagship. Other large public datasets follow (OpenStreetMap, open graph collections, Panama Papers), each turned once into Semurg's form so any peer can pull a slice or the whole thing, checked for free as it arrives.
Statusin progress, added over time
The ruletransformed once, then it is streamable to all
See what is coming → Growing
Straight talk

What works today, and what is next.

We would rather undersell than overclaim. Here is exactly where each part stands.

Live today
Download and install the node. This is live right now. Follow Start here and in a few minutes you have a node running on your own hardware, serving on your machine. Nothing about that is a promise, you can do it in the next five minutes.
Proven end to end
License-gated package delivery. We have moved a real package all the way through: a 49 MiB dataset slice, from one node to another, with the receiver checking every byte for free, surviving a hard kill mid-transfer, skipping the pieces it already had, resuming after the connection dropped, and gated by licence. The delivery mechanism on this page is not a hope, it runs.
One-click package delivery into the substrate. The last piece, the part of the engine that reads a delivered package with no wasted copies, is landing next. Until it does, this page shows you the capability and exactly how it works, honestly, part by part. When it opens, the node you already installed can pull the prepared packages under your licence the same day.
Download and install a node Tell me when one-click delivery opens
Why install now. A running node is ready. The moment one-click delivery opens, your node can pull Gemma or a large public dataset under your licence, with no head start needed.