AI infrastructure for crypto

Modern crypto has chains, DEXes, bridges, lending, NFTs, and governance — but almost no first-class decentralized intelligence layer.

The crypto world has built its own exchanges, its own lending, its own everything — except AI. There is no shared AI service that belongs to the network itself.

When a dApp wants AI today, it has exactly one real option: leave crypto. Concretely, it must:

When a crypto app wants to add AI today — a chatbot, an assistant, anything smart — it has one real option: go back to regular tech companies. That means it must:

• Pay OpenRouter, OpenAI, or Anthropic in hard money — USD, credit cards, centralized billing accountsBuy AI from OpenAI or similar companies with a credit card, in dollars
• Trust a centralized lab with its prompts, pricing, policy, and kill switchesTrust one company with what its users type, what it charges, and the power to cut the app off at any time
• Stay structurally dependent on Web2 AI while calling itself decentralizedKeep depending on big tech while telling users it is independent of big tech

So DeFi and dApps are inherently behind on product capability. They can move money trustlessly. They cannot think without leaving crypto rails. The smartest part of every "decentralized" stack today is a Web2 subscription with a card on file.

So crypto apps are stuck a generation behind normal apps. They can move money without banks — but they cannot do anything intelligent without renting a brain from the same companies they claim to replace. The smartest part of every "decentralized" app today is a normal tech subscription paid with a credit card.

Lux is the decentralized AI network those apps plug into — intelligence as a network primitive, like gas, oracles, or storage, but for AI.

Lux is the AI service crypto builds for itself. Any app can plug in, the way apps already plug into shared payment rails — but this pipe carries intelligence.

• Paid in $LXTH (light) — crypto-native fuel, not card-on-file dollarsPaid in light ($LXTH) — a token, not a credit card on file
• Bridges let other chains and dApps get AI without the OpenRouter hard-money dependencyBridges let apps on other blockchains swap their tokens for light and use the AI too
• LuxGPT is the first dApp on the network — a chat UI with a walletLuxGPT is the first app on it — a chat AI where your wallet is your account
• Later dApps put AI in their core using the same pipeFuture apps build AI into their main features using the same connection
• The base token has use first; other apps and DeFi (LPs, farms) enhance that useThe token is useful on day one — every answer costs light — and trading or investing layers come after the usefulness, not instead of it

Lux is AI infrastructure for crypto: decentralized intelligence dApps can embed so they stop depending on centralized AI vendors. LuxGPT proves it; bridges and other dApps scale it; $LXTH is the fuel.One-line thesis

Lux gives crypto apps their own AI, so they stop renting intelligence from big tech. LuxGPT is the working proof. Bridges bring in apps from every other blockchain. Light is the money it all runs on.The idea in one breath

Who is what

The network map

Protocol vs chain — read this once, never be confused again

Lux = our AI PROTOCOL / NETWORK (the product)
     - API, nodes, models, LuxGPT, light payments

Settlement = money + rules layer
     - Can start as credits in our ledger
     - Can use an EXISTING public chain for deposits/payouts/bonds
     - We are NOT launching our own L1 blockchain as the launch goal
     - Users do NOT "buy AI with ETH" as the product story
     - $LXTH / light is the AI fuel
     - If an ETH-family chain settles value, gas is only postage

User-facing framing: AI that lives on a blockchain. Builder footnote: models execute on GPUs; the chain settles value and protocol rules.

One request, start to finish:

What happens when you ask the network a question:

1. A user or dApp sends a request — through LuxGPT or the Lux APIYou (or an app) ask a question — through LuxGPT or through the plug any app can use
2. The network picks a capable node by real delivered speed and reliability, not advertised specsThe network picks a computer with a proven track record of fast, reliable answers — not one that just claims to be fast
3. The node runs the official open model version (digest-pinned, so substitutions fail)That computer runs the official AI model version — it is checked, so a fake or downgraded model gets caught
4. The answer streams back
5. The user’s wallet shares light — most of it to the operator, small cuts to treasury and opsYour wallet pays a little light — most goes to the person whose computer answered you
6. If the node fails, another takes over — the user is not charged for failed workIf that computer fails mid-answer, another takes over — you never pay for a failed answer

Fast nodes first

Connectivity and proven throughput get first bursts of traffic. Slow or fake capacity gets less work. Advertised specs are a hint; delivered answers are the score.

Serving modes — Replica and Swarm

Two ways a model gets served:

There are two ways the network can run a model:

• Replica mode — the full model on one Worker (or one multi-GPU box). Best latency; the default for most chats.the whole model fits on one machine. Fastest; the normal case for chat.
• Swarm mode — the model sharded across multiple Workers so combined VRAM and parameters exceed any single device (pipelined). This is the “many miners = a larger model” path.the model is split across several machines, so together they can run an AI too big for any one of them. This is how many small miners add up to a bigger brain.

Honest physics: swarm is not shared HBM across the planet — activations cross the network between shards, so swarms prefer geographic and pool affinity (unlike ETH pools, which were global because their messages were tiny). Lux composes proven open runtimes — vLLM-class for replicas, Petals-class (MIT-licensed) for swarms — and owns payment, identity, and routing policy. We are not inventing CUDA, and we do not claim a day-one home mesh matches datacenter latency.

Honest physics: the split-up mode is not magic shared memory across the planet — the machines pass data to each other over the internet, so it works best when swarm members are near each other. Lux builds on proven open-source engines for both modes and adds the payment, identity, and routing layer. We are not claiming a network of home PCs instantly matches a datacenter.

On Petals specifically: a swarm miner is a Lux Node wrapping a Petals-style server; the gateway may serve a request through vLLM or a Petals client — the API is Lux, not “just Petals.” Petals is not a privacy layer — peers process job data (see §8) — and it is NVIDIA/CUDA-first; AMD support is secondary and harder.The split-up mode uses well-known open-source tech under the hood. Important honesty: that tech does not hide your data from the machines doing the work (privacy is handled separately — see §8), and it works best on NVIDIA graphics cards.

Multi-agent is not a special mode: an agent team is just many concurrent metered calls fanned out across nodes through the same OpenAI-compatible API.

Integrity at V1

• Correct-model-version checks on every node (digest pinning)
• Challenge probes with known answers
• Occasional redundant checks across nodes
• Bonds, and removal for cheaters
• No zkML required at launch — integrity is economic and operational

Engineering detail lives in the appendix.

One token, one wallet, two directions. That is the whole model.

1. Mine — light enters your walletRun a node (mine) — light enters your wallet as pay for answering requests
2. Use LuxGPT or the API — light leaves your wallet to pay operatorsUse the AI — light leaves your wallet to pay the people running the computers
3. Same token, same wallet — no separate mystery currency for users
4. Holding is fine; network health is light moving
5. Product language: share light means pay, receive light means earn — both always defined in plain words

Share your light, and others will share theirs.Product language — in actual English: pay for AI, get paid for serving it

Where each payment goes

Illustrative default; a parameter, not scripture. The split applies to light_work; the small per-request network fee funds protocol capacity separately. What is fixed: operators keep the large majority.

Mining — two classes, one rule: verified useful work

Mining on Lux is not proof-of-work racing. The protocol assigns real jobs; completed, verified work pays light. No pay for empty heartbeats.

“Mining” here does not mean burning electricity on puzzles. Your machine does real, useful jobs, and you get paid light for the work it verifiably finished. Idle machines that just claim to be online earn nothing.

Operators choose their role. The average person mines Host; GPU owners mine Worker — or Both, because hosting is CPU- and network-bound: a 3090 should never waste its GPU serving static files while the same PC can host on CPU as the GPU does AI.You choose your role. Anyone with a normal computer can mine as a Host; anyone with a gaming-class GPU mines as a Worker — or does Both at once, since hosting barely touches the GPU: the graphics card does AI while the rest of the machine hosts. Of the ~92% operator share on an AI request, the large majority goes to the Worker that ran the model, with a narrower share to any Host node that actually helped serve that path. Hosting-only jobs (serving a dApp, no AI call) pay Host miners directly.

Pools — steady pay, ETH-pool spirit

Solo mining is fine for skilled operators. For everyone else, pools give the smooth paycheck: the pool takes jobs, members do the work, and light is distributed proportional to each member’s verified work, minus a small pool fee. Worker pools and Host pools are separate (per class). Same spirit as Ethereum-era mining pools — but the mechanism is a useful-job market, not racing to find the next block. Many small solo miners do not slow Lux down (jobs run in parallel); what hurts is flaky nodes and bad routing — pools smooth both reliability and income.

You can mine alone, but most people will join a pool: the pool collects jobs, everyone’s machines do their share, and the earnings are split in proportion to the work each machine actually did (minus a small fee). It works like the old Ethereum mining pools people remember — a steady paycheck instead of a lottery on every job — except the work is real AI jobs, not puzzle-racing. Lots of small miners doesn’t slow the network down; unreliable machines do, and pools smooth that out.

Metering — light is AI work at human scale

Light is AI work capacity, rescaled for humans. The network counts input and output tokens exactly the way modern AI APIs do; those raw counts convert into light ($LXTH) at a fixed scale with published weights, so people hold solid coin amounts while the ecosystem reasons in familiar token units.

Light is a unit of AI work, sized for humans. The network counts how much text goes in and comes out of the AI (the industry calls these counts “tokens”), then converts them into light at a fixed exchange scale — so a normal conversation costs a small, sensible fraction of one coin.

billable_units = (input_tokens × w_in) + (output_tokens × w_out)
light_work     = billable_units / SCALE × model_rate × privacy_rate

SCALE = 1,000,000
w_in  = 1
w_out = 4        # generating text is heavier than reading it
model_rate   = 1.0 base/fast open models; higher for larger models —
               they lock more VRAM and model slots (published per model)
privacy_rate = 1.0 Direct; higher (e.g. 3×) for Private / TEE jobs

light_network_fee = base_fee_per_request × congestion_rate
   # per tier (fast / large / private); rises when free capacity
   # for that tier is low; floors above zero so spam is never free

light_total = light_work + light_network_fee

1.0 $LXTH  ≡  1,000,000 billable units at model_rate 1.0

Output weighs more than input because generation is heavier than reading — the industry-standard asymmetry; equal weights would underpay long answers and starve node economics. Larger models cost more via model_rate because they tie up more VRAM and model slots — the primary scarcity — and more GPU time, the secondary one. It is not “same light, just wait longer”: that would underprice scarce memory. The per-request network fee works like gas — a small congestion-priced floor that keeps spam expensive and prices capacity per tier. Examples of light_work at model_rate 1.0: a 2,000-in / 500-out chat is (2000 + 2000) / 1M = 0.004 light; a 100,000-in / 2,000-out document job is (100000 + 8000) / 1M = 0.108 light.

Answers cost more per word than questions, because generating text takes far more computing than reading it. Bigger, smarter models cost more per use — they occupy much more of a machine’s memory, which is the scarcest thing in AI — and private-mode jobs cost extra (see §8). On top of the work price there is a tiny per-request network fee, like postage, which rises when the network is busy and never drops to zero — so spamming the network is never free. In practice: a normal chat message costs about 0.004 light; feeding the AI a long document costs about 0.1 light. Whole conversations cost fractions of a single coin.

Supply & circulation

• Fixed, plentiful supply: 1,000,000,000 LXTH (1 billion) total — no ongoing emissions printer
• Light circulates; it is not burned per chat. Payments flow to operators, who hold or spend; abandoned light returns by Will or Sunrise. Light never disappears from the living network.Nothing is ever permanently destroyed or lost.
• Chain decimals: enough decimals (6/9/18) that fractional light works everywhere; with 6 decimals, 1 base unit aligns cleanly with 1 billable unit

What light is not

• Not a separate species from AI tokens — light is AI-token work, rescaled (1 LXTH ≡ 1M billable units), not an unrelated currency bolted on
• Not ETH as the product currency — if a public chain settles value, gas is only postage
• Not a pure meme with no sink — every AI answer is a sink

Why light gains value: use first, then DeFi

1. Use first — LuxGPT, the API, and nodes all need $LXTH to functionUsefulness first — the chat app, the plug, and the miners all need light to work at all
2. More dApps put AI in their core → more demand for lightMore apps add AI features → more people need light
3. Bridges — foreign apps and chains pay light for AI, dropping their OpenRouter USD dependency
4. LPs and farming around $LXTH become valuable because real demand existsTrading and investing around the token become worthwhile because people actually need it

Order matters: utility → apps → liquidity. Not farm-first cosplay.

LuxGPT is proof the network works: a chat app where the account is a wallet and the bill is light.

LuxGPT is the working proof: a chat AI that feels like ChatGPT, except your account is a crypto wallet and each answer costs a tiny bit of light instead of a monthly subscription.

1. Create a wallet — that is the whole signup
2. Receive welcome light — starter light to try the network
3. Chat — each answer shares a little lightcosts a little light, metered by input + output size
4. Optionally mine — the same wallet receives light for verified work, and mining puts you in the Sunrise drawsearns light for real work — and mining is what enters you in the lottery draws
5. Your history stays yours — wallet-protected, never published on a chain (details in §8)

LuxGPT is deliberately ordinary to use — it should feel like any modern chat AI. The difference is underneath: open models, decentralized capacity, and a wallet instead of a card on file. It is the first dApp, not the ceiling.

DeFi can be decentralized for money movement and still centralized for brains. That makes the whole stack incoherent — and behind.

A finance app can run without banks and still rent its brain from a big tech company. That is the contradiction Lux removes.

AI in the core of any dApp

Any dApp can embed intelligence through the Lux API: chat, agents, risk explainers, NPCs, support, code generation, personalization. Paid in $LXTH — optionally accepting other tokens and swapping into light under the hood, so the user never has to think about it.

Any crypto app can add smart features through the same plug: a support chat, an assistant that explains a risky trade in plain words, game characters that talk, code helpers, personalized screens. The app pays in light behind the scenes — its users may accept other tokens that get converted automatically, and never need to think about it.

Bridges

Bridges move value from other chains into $LXTH so foreign apps can pay for Lux intelligence natively.let apps and users on other blockchains convert their tokens into light and use Lux AI, without ever touching a dollar.

Bridges use $LXTH so other decentralized apps finally get AI without spending hard money on OpenRouter. They stay on crypto rails; intelligence comes from Lux.The pitch

An app on any blockchain can swap its own tokens for light and get AI — no dollars, no credit card, no big-tech account. The money stays crypto; the intelligence comes from Lux.The pitch

The sequence: LuxGPT proves it → the API opens it → bridges scale it. Later dApps enhance demand for the base token; they never replace the fact that the token already has use.

The Sunrise lottery is for miners. Mine in the period — Worker or Host — and each draw could pay you an entire pot of abandoned light.

The Sunrise lottery is for people who mine — even on a normal PC. Keep your machine doing verified work, and about twice a year you have a shot at winning an entire pot of abandoned light.

The incentive is deliberate: users pay light for AI; miners earn light plus lottery upside — a reason for capacity, and for dormant devices, to stay online.The split is deliberate: if you just chat, you pay light. If you mine, you earn light every day and hold a lottery chance — a reason to put that idle computer to work and keep it online. It is also a real property rule: on Lux, light never disappearsabandoned balances are recycled instead of being lost forever — unlike the millions of BTC that are gone for good.

The rules

Welcome light still greets every new wallet — enough to try LuxGPT and hold light within. But the lottery is earned: only miners are in the draw.New wallets still get free starter light to try the chat. But the lottery has to be earned: only people whose machines did real work are in the draw.

Light never disappears.Conservation rule — and the reason the lottery pool exists at all

Sunrise is a recirculation of existing abandoned light under disclosed protocol property rules — nothing is minted. Not financial advice; tax treatment of received light is the recipient’s responsibility.

Users will send confidential data. That is the design assumption, not an edge case — so Lux ships two labeled serving modes instead of one pretended guarantee.People will paste sensitive things into an AI — that is normal, and Lux is designed assuming it. So there are two clearly labeled modes instead of one vague promise.

Two modes

TEE = Trusted Execution Environment: a hardware “safe room” — primarily CPU technology (Intel TDX, AMD SEV-SNP) — whose attestation proves the approved Lux runtime is running, re-checked periodically. Fail the check → no private jobs, no 3×. Strong private LLM serving ideally adds GPU confidential computing (H100-class) — which consumer cards do not have.TEE means a hardware “safe room” inside the processor: the network can verify the machine is running the approved, sealed software before trusting it — and re-checks regularly. Machines that fail the check get no private work and no bonus pay. The strongest version also needs special datacenter-class GPUs; ordinary gaming cards do not have that feature.

Hardware honesty — what a 3090 can and cannot do

• An RTX 3090 is excellent for Direct inference, training/enhancement jobs on public or opt-in data, and hostingA gaming GPU like a 3090 is great for normal AI answers, for model-improvement jobs on public data, and for hosting
• It is not full GPU-confidential-computing hardware — it cannot serve Private inference the way an H100-class card canIt cannot run the sealed private mode — that takes datacenter-class hardware
• Under a strong-privacy regime, 3090s keep mining light via train/enhance/host work while private chats route to TEE-capable Workers and poolsSo if most chats go private one day, gaming GPUs still earn — they just do the other kinds of work while sealed machines handle the private chats

All-private-only becomes an option only when TEE (plus GPU-CC) supply is real. Until then, dual mode — labeled honestly.

Session security — always, in both modes

• Your wallet seed never goes to a miner. Jobs carry a per-job auth token and session key, wiped after the job
• History is encrypted at rest so your wallet unlocks it; TLS in transit; chats never touch a public chain
• Operator policy — no logging, no reselling — enforced by bonds and removal; deterrence, not a substitute for TEE

The honest limit: “only the wallet can decrypt during remote GPU inference” is not how LLM serving works without TEE — decryption happens in the serving path, on the serving machine. Direct mode accepts that with policy + bonds; Private mode seals that path in hardware. Whoever runs the model layers sees the job — unless their machine is sealed. A remote 3090 cannot do private model labor while a TEE elsewhere “holds the keys.”The honest limit: for an AI to answer you, the machine running it has to read your words at that moment. In Direct mode we manage that with rules, deposits, and removal; in Private mode the reading happens inside the sealed chip, where even the machine’s owner cannot look.

Horsepower vs the hosted environment

Miners supply horsepower; jobs run inside a Lux-managed hosted environment (container/VM) on that metal. GPU passthrough keeps CUDA — virtualizing does not cost the GPU when passthrough is done right. Private = the same hosted environment, sealed by TEE, on capable hardware. Pools may run Petals-class swarms internally for large models; the pool aggregates ops and trust, the TEE is the lock on the machines, and bonds/strikes are after-the-fact deterrence — never the whole privacy story.Miners provide the raw machine power; the actual jobs run inside a locked, Lux-managed workspace on their machines — set up so the graphics card still runs at full speed. Private mode is that same workspace running inside the sealed chip. Mining pools can team machines up internally to run bigger models; the seal is what protects data, and the deposit-and-punishment rules are the backup, not the main lock.

Blunt answers, in both language modes. If a pitch deck contradicts this page, this page wins.

Engineering depth, brand record, and boilerplate — collapsed so the main path stays readable.

R_i = EWMA( output AI tokens delivered / wall seconds )

scheduling weight = f(R_i, success rate, free slots, bond, recent strikes)