Permanent data. Durable memory.

Pay once and the network keeps your data for good.

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

const cascade = new Cascade(client)

const result = await cascade.upload(file)

console.log(result.txHash)
console.log(result.contentId)

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 is the layer that shipped first, because none of the others work without it. Hover any capability to see what it rests on 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.

Permanent storage, 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, and still provably there 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, so an action can always be traced to whoever was allowed to take it.

More than a name. A record with a history.

An API key is a secret that grants access. An identity is a thing that accumulates: what it may do, what it has done, and who it lent authority to.

What a real identity makes possible.

Answers you can check, not answers you have to believe.

Actions that produce cryptographic receipts proving what work was performed, so a result can be re-derived by someone else rather than taken on faith.

Enough to run it again, without trusting anyone.

A receipt is not a log line saying the job finished. It carries everything a second party needs to do the work themselves and compare.

What becomes possible when work is checkable.

Payment that waits for the work to check out.

Protocol-native settlement, escrow and incentives for decentralized services, so an application or an agent can hold a budget, pay a provider, and be paid itself.

Money moves in one direction, and only once.

There is no invoice, no net-30, and no dispute window where the money sits with whoever happens to hold it. Each stage is a state the protocol enforces.

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 is one paid job.

Not a review, not a score someone assigned. A line between two identities exists because work was requested, delivered, checked and paid for, and each of those is recorded.

Every edge is a job that was paid for.

Every job leaves a signed receipt, and the receipts add up into a record of who actually delivers.

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

Trusted for research. Untested for finance. A single star rating could never 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.

What we shipped, and why.

Two roles run the network.

Validators secure the chain. SuperNodes run the services. They are separate on purpose, because consensus should never depend on who is serving a file.

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.