Domain roles · invitation preview

A role in a domain — not a node you can take away.

Structure, responsibility and context — something you take part in, not something you take with you.

Today it proves that open-source code actually works: it runs each package's own test suite and keeps only the reproducible result as evidence. 1,997 proven results so far — across Rust, Go, Python, JavaScript and PHP — and every one you can re-check on your own machine.

Zynko isn't an LLM — no GPU farm, no terabytes. It proves what it knows, and it stays small enough to run on your own hardware.

Today's AI recomputes everything, every time — burning power over and over for answers it already found. Zynko proves an answer once — however long that first proof takes — then never runs it again: the result is kept and reused, forever, at no further cost. The saving isn't a faster chip; it's the thousand re-runs that never happen. Not a promise — something you can check.

Apply for a role The four roles How it works

Invitation-only for now · a role is bound to your key and to the domain — non-transferable, and it expires

What you get — and what you don't

You don't get a node — you get a role. The node stays, but as the verification step, under the domain's rules, not as a tool you can carry off.

Role	Can do	Cannot do
Observer	reads capsules and status, checks chain integrity	does not validate, write or forward
Validator	runs the deterministic check — this is the node role	does not create capsules, does not grant roles
Relay	forwards capsules, builds topology	cannot modify a capsule — any change is a different hash
Domain-Maintainer	owns the domain's field set, grants and revokes roles	cannot overwrite a sealed capsule; cannot grant for another domain

Why it cannot be taken away

Not because we encrypt it — because a copy cannot be continued. Every capsule hash covers the domain's identifier and the previous capsule; without the domain's key you cannot produce a valid successor to a copied chain, and it cannot be passed off as a different domain either.

What we do not claim: copying bytes cannot be prevented, and anyone can start their own domain with this same code. What the system guarantees is that it is not this domain.

The "prove once, never recompute" argument above has a name: dedup. The system asks by the content's fingerprint whether it already exists, and adopts any result it finds after verifying it — it doesn't recompute, but it doesn't take it on trust either.

The shape of what you get — an illustrative example of the format, not a specific claim. A real answer always carries its own re-runnable proof.

Capsule

The executable truth.

In the Capsule House, information becomes precise.

We don't interpret — we confirm.

We don't guess — we demonstrate.

We don't approximate — we reproduce.

A capsule is a new kind of unit: reliable, repeatable, verifiable.

Step inside and see how truth is made.

Enter

We're opening the network to invited partners who lend a machine — a spare GPU box, a server, even a modest node. In return, founding contributors keep free, unlimited access for life. Every machine that joins makes the network stronger — its combined compute is what lets Zynko grow. Your machine stays yours: its private keys are generated on your side and never leave it.

Already taking part? See your dashboard ↗  ·  Cautious? Read the node package first ↗ — it's plain and inspectable.

After all of that this might sound like a contradiction — so let's be exact. Running the network needs no GPU; the deterministic, verifiable work runs on ordinary CPUs, and that's the whole point. Generation is the one exception. Video, image and audio generation is physics-bound to the accelerator — we don't pretend to do it on a CPU, and we say so plainly. It runs on partner GPUs. That's a partition, not a race we claim to win: the provable work is ours, forever; the creative generation stays where it belongs. If you have a GPU sitting idle, that's the compute the network actually needs, and it earns you the same lifetime access.

Joining costs you nothing but spare compute. Your machine is never asked to hold anyone's secrets, it only ever sees its own task, and nothing it produces can quietly harm the network — because every result is checked before it counts. And you never have to trust us on any of this: you can verify it yourself.

Zynko isn't one big brain — it's many small ones. Every subject grows its own little world, with its own proven knowledge and its own people deciding what to explore next. Astronomy, code, mathematics, biology, video — and whatever you bring.

Invitation-only preview. A public intake opens once the first cluster is stable — everything above is the model we're building to, not a claim that it already runs at planetary scale.