Permanent data. Durable memory.

Pay once and the network keeps your data for good.

import { createLumeraClient } from "@lumera-protocol/sdk-js"

const client = await createLumeraClient({
  preset: "mainnet", signer, address
})

// hashes the file, registers on chain, stores across supernodes
const task = await client.Cascade.uploader.uploadFile(file, {
  fileName: "report.pdf",
  isPublic: true,
  expirationTime
})

import { Lumera } from "@lumera-protocol/sdk-js"

const lumera = new Lumera({ apiKey: process.env.LUMERA_API_KEY })

const memory = await lumera.memory.open(agentId)

await memory.remember({
  user: "Alice",
  preference: "Window seat"
})

const context = await memory.recall()

Consensus where it matters. Execution where it scales.

Lumera separates consensus from decentralized services. The blockchain records requests, payments, governance, and cryptographic proofs while economically bonded SuperNodes perform storage, verification, and decentralized execution. This allows sophisticated protocol services to scale independently without compromising security or decentralization.

Three ways in.

Write to the network, hold data for it, or secure it. Each one is open today.

Where the network talks.

Pick the one that matches what you need.

Build where work is provable.

One Architecture.Five Capabilities

Permanent data, identity, verifiable execution, settlement and trust on a single protocol, with memory live on mainnet and each capability built on the one beneath it.

Memory at the base. Everything else stands on it.

Durable memory shipped first because every other capability depends on it. Hover over each capability to see what supports it and which parts of the network it uses.

What’s missing today, and how Lumera solves it.

The gaps are architectural, not incremental, and they depend on each other. Identity without settlement is unenforceable. Settlement without identity is unaccountable. Open any row to see what breaks today and what replaces it.

When an agent is wrong, the damage is contained.

Three classes of execution, three consequences when something goes wrong. They never collapse into each other.

Build where work is provable.

One token, four structural jobs.

LUME is the settlement asset, the security bond, the reputation stake and the governance weight. Each job is tied to activity you can look up on the explorer.

Every job makes the next one easier to trust.

Everything you need to build on Lumera.

Durable memory, identity, verifiable execution and settlement behind one SDK and one economic model. Build against stable interfaces.

How settlement works

A memory you can prove.

Written once. Readable from any framework, agent or model. Provably intact decades from now.

Pay once. Prove it forever. Take it anywhere.

Storage nobody has to take on trust.

Paying an operator to hold data is not the same as knowing they still have it. The network settles that question continuously, on its own, without anyone asking.

Three calls, start to finish

import { Lumera } from '@lumera-protocol/sdk-js'

const lumera = new Lumera({ apiKey: process.env.LUMERA_API_KEY })

// 1. open the memory an agent writes under
const memory = await lumera.memory.open(agentId)

// 2. remember a fact once, it is kept forever
await memory.remember({ units: 'metric' })

// 3. recall it from any framework or model
const context = await memory.recall()

// 4. ask the network to prove it is still there
const proof = await memory.prove(context.id)

Questions we get asked

An identity you own, not a key a vendor issued.

Cryptographic passports that enforce permissions and delegated authority for people, applications and autonomous systems. Every action can be traced to the identity authorized to take it.

More than a name. A record with a history.

An API key grants access. An identity carries a permanent record of what it can do, what it has done and where it has delegated authority.

What a real identity makes possible.

Answers you can verify, not answers you have to trust.

Every action produces a cryptographic receipt showing what was done, so anyone can independently verify the result rather than take it on faith.

Enough to verify it, without trusting anyone.

A receipt is more than a log saying the job finished. It records what was used, what was run and what came back, giving another party what it needs to replay the work and compare the result.

What becomes possible when work is checkable.

Payment that waits for proof.

Protocol-native settlement, escrow and incentives for decentralized services. Applications and agents can hold budgets, pay providers and earn payment for completed work.

Payment moves when the work is verified.

No invoice. No net-30. No uncertainty over who holds the funds while the work is being completed. Each stage is recorded and enforced by the protocol.

What settlement unlocks.

A record of who actually delivered.

Trust built from verifiable protocol activity rather than from intermediaries or reputation alone, accumulated one paid job at a time.

Every connection in the graph represents a completed job.

It is not a review or a score assigned by someone else. An edge connects two identities because work was requested, delivered, verified and paid for, with every stage recorded by the protocol.

Trust compounds with every verified job.

Each completed job leaves a signed receipt. Together, those receipts create a durable record of who consistently delivers.

Click a participant to see what the network knows about them.

Trusted for research. Untested in finance. One universal score cannot tell you the difference.

Why a record beats a rating.

Lumera in the press.

Coverage, interviews and commentary, including appearances by co-founder Anthony Georgiades.

Brand assets.

The wordmark, symbol, colour values and type that make up Lumera. Take what you need. Use it accurately and in good faith, under the terms further down this page.

Green is a fill colour. As small text on a light background it does not carry enough contrast, so use Teal there instead.

Good faith, plainly stated.

You do not need to ask permission to refer to Lumera accurately. You do need to be straight about what your relationship with the project actually is.

What we shipped, and why.

Two roles power the network.

Validators secure the chain. SuperNodes deliver its services. The roles are separate by design, so consensus never depends on service delivery.

Permanence funded, not promised.

A stored artifact must remain available for years. A verifier must be ready before it is needed. An operator must be paid for capacity, not only utilization. Everlight is the economic floor under all five capabilities.

The network pays for itself.

Three revenue streams fund the people who secure the chain and the people who hold the data. Every one of them is paid in LUME, settled on chain, and tied to work that was actually done.

Who Lumera connects to, and how.

A logo wall tells you nothing. Each entry below says what the relationship actually is.

An economy where software can be trusted with real work.

Agents are already doing work that matters. What they lack is everything that makes work accountable: a memory that survives, an identity of their own, evidence of what they did, and a way to be paid for it. Lumera is building all of it on one architecture.

What this makes possible.

Memory is live on mainnet today. The other four are being built on it.