Atoms

The unit of the knowledge graph — anything you can name, given canonical bytes and a deterministic ID.

An atom is the unit of the knowledge graph. Anything you can name becomes one: a song, a repo, a person, a place, a book, a token, a URL. One atom is small. Millions of them is a graph.

Concretely, an atom is two things bound together — atom data (canonical bytes describing the thing) and an atom ID (a deterministic hash of exactly those bytes). Everything else in Intuition — triples, vaults, markets, wallets — hangs off that pair.

Atom data is canonical JSON-LD#

Atom data is a JSON-LD blob on a schema.org type. The classifications package defines 37 canonical shapes — browsable at /classifications.html — and @0xintuition/primitives gives each one a typed builder:

build-atom.ts

import { buildMusicRecording } from "@0xintuition/primitives/atom";

const atom = buildMusicRecording({
  name: "Alive",
  byArtist: "SoDown",
  sameAs: ["https://open.spotify.com/track/2GdXO1xk…"],
});
// → { success, value: { classification, data, id, values } }

The builder validates the fields and emits identity-stable bytes:

atom-data.json

{
  "@context": "https://schema.org",
  "@type": "MusicRecording",
  "name": "Alive",
  "byArtist": "SoDown",
  "sameAs": ["https://open.spotify.com/track/2GdXO1xk…"]
}

The classifications layer is a validator, not an executor — it shapes the JSON; it doesn't move bytes onchain or write to a database for you. The point is that everyone uses the same shape, so the data lines up later.

The ID is a pure function of the bytes#

atom-id.ts

import { calculateAtomId } from "@0xintuition/ids";

const atomId = calculateAtomId(value);
// keccak256(SALT ‖ keccak256(bytes)) — the ID the contract derives too

No wallet, no gas, no network call. Same content, same ID — in your app, in anyone else's, and onchain. This is what makes atoms safe to create offchain at volume: identity is settled from the first line of code. Details in Deterministic IDs.

Because the ID hashes the exact bytes, sameAs is part of identity. Write canonical source URLs into sameAs at creation and independent apps converge on one atom. Skip it — or hash variant URLs — and the same song fractures into duplicates with split history and split signal. Read the graph before you create; reuse the atoms that already exist.

Atoms live offchain first#

An atom doesn't need a chain to exist. Derive the ID locally, store the atom data in your own database keyed by that ID, and build your whole product on it — free, instant, high-volume. Users can tag, save, review, and curate with zero friction while your app accumulates graph-shaped data under stable IDs.

Onchain, an atom becomes multiplayer#

When a record is worth keeping, the same bytes are published to the MultiVault contract, which derives the same ID. The atom is promoted, not re-created. Onchain it gains the properties of being onchain:

a vault on a bonding curve — TRUST deposits price conviction in the record
its own Ethereum address — every thing in the graph is also an account
a permanent, immutable home anyone can read, extend, and build on

The full path is Offchain to Onchain. And atoms rarely stand alone — the claims connecting them are Triples & Predicates.