Contents
In actual English
Lux is a network of computers (mostly GPUs) that run open AI models.
You create a wallet. You can receive light ($LXTH) — including welcome light when you sign up, and a chance at Sunrise lottery draws. You use LuxGPT (a chat app) or the Lux API by paying light from that wallet. If you run a Lux Node, you earn light for answering requests.
Other dApps — on Lux or on other chains via bridges — can add AI to their product by paying light, instead of paying OpenRouter or OpenAI in dollars.
The blockchain holds balances, payments, and rules. The AI models run on nodes (GPUs). Together: AI that lives on a blockchain network.
The problem: crypto can move money. It cannot think.
Modern crypto has chains, DEXes, bridges, lending, NFTs, and governance — but almost no first-class decentralized intelligence layer.
When a dApp wants AI today, it has exactly one real option: leave crypto. Concretely, it must:
- Pay OpenRouter, OpenAI, or Anthropic in hard money — USD, credit cards, centralized billing accounts
- Trust a centralized lab with its prompts, pricing, policy, and kill switches
- Stay structurally dependent on Web2 AI while calling itself decentralized
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.
The solution: Lux
Lux is the decentralized AI network those apps plug into — intelligence as a network primitive, like gas, oracles, or storage, but for AI.
- Paid in $LXTH (light) — crypto-native fuel, not card-on-file dollars
- Bridges let other chains and dApps get AI without the OpenRouter hard-money dependency
- LuxGPT is the first dApp on the network — a chat UI with a wallet
- Later dApps put AI in their core using the same pipe
- The base token has use first; other apps and DeFi (LPs, farms) enhance that use
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
Who is what
| Layer | Name | Role |
|---|---|---|
| Project | Lux Ethos | Name and character of the project |
| Network / protocol | Lux | The AI network people join |
| Unit of value | light | What you share and receiveWhat you pay and earn |
| Ticker | $LXTH | On-chain symbol for light |
| First dApp | LuxGPT | Chat app: connect wallet, use AI, pay light |
| Operator software | Lux Node | Run GPUs, receive light for workget paid in light for work |
| Builder surface | Lux API | OpenAI-compatible API for any app |
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 postageUser-facing framing: AI that lives on a blockchain. Builder footnote: models execute on GPUs; the chain settles value and protocol rules.
How it works
One request, start to finish:
- A user or dApp sends a request — through LuxGPT or the Lux API
- The network picks a capable node by real delivered speed and reliability, not advertised specs
- The node runs the official open model version (digest-pinned, so substitutions fail)
- The answer streams back
- The user’s wallet shares lightpays light — most of it to the operator, small cuts to treasury and ops
- If the node fails, another takes over — the user is not charged for failed work
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.
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.
Tokenomics: one loop
One token, one wallet, two directions. That is the whole model.
- Mine — light enters your wallet
- Use LuxGPT or the API — light leaves your wallet to pay operators
- Same token, same wallet — no separate mystery currency for users
- Holding is fine; network health is light moving
- 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. What is fixed: operators keep the large majority.
Metering — what a request costs
You pay roughly like modern AI APIs: input size + output size — measured in text pieces the industry confusingly calls “AI tokens” — converted into a light ($LXTH) cost for that model tier. AI tokens are a meter, like kilowatt-hours. Light is the money.
What light is not
- Not “AI tokens” — those are text pieces for metering input/output size
- 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
- Use first — LuxGPT, the API, and nodes all need $LXTH to function
- More dApps put AI in their core → more demand for light
- Bridges — foreign apps and chains pay light for AI, dropping their OpenRouter USD dependency
- LPs and farming around $LXTH become valuable because real demand exists
Order matters: utility → apps → liquidity. Not farm-first cosplay.
LuxGPT — the first dApp
LuxGPT is proof the network works: a chat app where the account is a wallet and the bill is light.
- Create a wallet — that is the whole signup
- Receive welcome light — enough starter light to try the network and be eligible for Sunrise draws
- Chat — each answer shares a little lightcosts a little light, metered by input + output size
- Optionally run a Lux Node — the same wallet receivesearns light for serving others
- 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.
For other dApps & bridges
DeFi can be decentralized for money movement and still centralized for brains. That makes the whole stack incoherent — and behind.
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.
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
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.
Will & the Sunrise lottery
Open a wallet. Get welcome light. Use LuxGPT. And on a set cadence, Sunrise redistributes abandoned light to active wallets — you might win a large share.
This is a deliberate reason to create a wallet and stay active. 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
| Rule | Detail |
|---|---|
| Dormancy | ~5 years of no activity → light counts as abandoned (unless a Will exists) |
| What resets the clock | Using LuxGPT, paying via the API, mining, app sign-in, a manual refresh, updating your Will |
| The Will | Name heir wallet(s); heirs get the light first, always |
| No Will + dormant | Light enters the Sunrise lottery pool |
| Cadence | Memorable and regular — e.g. every 6 months (a parameter) |
| Eligibility | Active wallets that already hold light — “light within” stops empty-address spam |
| Philosophy | Light never disappears — contrast lost BTC |
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.
Trust & privacy — honest tiers
Your chats are not public and not on-chain. We design so content is wallet-protected and, on the confidential path, readable only inside secure hardware — not by random operators or the public.
Tier 1 — baseline (ships with V1)
- Chat history encrypted and wallet-controlled at rest
- TLS for everything in transit
- No prompts on any public chain — the chain settles balances and rules, never content
- Operator policy: no logging, no reselling — enforced with bonds and removal
Tier 2 — confidential compute (the architecture goal)
- TEE / secure-enclave nodes: even the machine’s owner cannot read plaintext
- Wallet-signed session keys; content decrypts only inside attested hardware
- Target: confidential nodes as the LuxGPT default; ordinary nodes for opt-in or less sensitive jobs
What we do not claim: mathematical impossibility of any node ever seeing data on the ordinary tier. Tier 1 is policy + economics + encryption at the edges; Tier 2 is hardware-enforced. We say which tier a job runs on, and we do not pretend one is the other.
Roadmap
| Phase | What ships |
|---|---|
| 0 | Working demo: API + nodes + metering + early LuxGPT |
| V1 | External nodes, wallet light share/receivepay/earn, LuxGPT as first dApp, OpenAI-compatible API |
| V1.5 | On-chain settlement rails, stronger privacy path (confidential nodes), training-fund jobs |
| V2 | Will + Sunrise lottery live, bridges for other dApps, more dApps with AI cores, LPs/farms around real demand |
No custom L1 vanity chain. No social-network product. No emissions-only fake traction. These stay cut unless real data forces a revision.
Hard questions
Blunt answers, in both language modes. If a pitch deck contradicts this page, this page wins.
Q01What is Lux, in one paragraph?
A decentralized network of GPU nodes running open AI models, with a wallet token (light / $LXTH) that you share to use AI and receive for serving ityou pay with to use AI and get paid in for running a node. LuxGPT is the first app on it — a chat AI whose account is a wallet. Any other app can plug in through an OpenAI-compatible API, and bridges let apps on other chains do the same. The blockchain layer records balances and rules; the AI runs on the nodes.
Q02Is this just another chatbot coin?
No. A chatbot coin is a token stapled to a UI. Lux is a protocol — nodes, API, metering, settlement — and LuxGPT is just its first dApp, the way one flagship app proves a platform. The token is the network’s payment rail with a real sink (every AI answer costs light), not a mascot.
Q03Why will dApps use this instead of OpenRouter?
Because OpenRouter is hard money and a centralized dependency: USD billing, a card on file, a vendor who can change pricing, policy, or shut you off. A dApp using Lux pays in crypto from its own rails, keeps its decentralization story coherent, and gets open models with transparent metering. Where Lux is also price-competitive, the choice stops being ideological.
Q04How do bridges fit?
Bridges move value from other chains into $LXTH so foreign apps can pay for Lux intelligence natively.Bridges convert tokens from other blockchains into light, so an app on another chain can use Lux AI without touching dollars. That makes Lux the AI backend for multi-chain crypto, not just for apps living on one network.
Q05What is $LXTH actually used for?
Paying for AI (LuxGPT, API, any embedded dApp usage), getting paid for serving AI (node operators), eligibility for Sunrise draws (you must hold light), and later: bonds/stake for operators and treasury coordination. Every answer the network produces is paid for in light — that is the sink.
Q06How do I get light “for free”?
Three honest ways: welcome light when you create a wallet, Sunrise lottery draws if you stay active and hold light, and mining — running a node that does real work. There is no staking-APY printer; nobody is promised yield for parking tokens.
Q07Is Sunrise a lottery?
Yes — as product motivation, that is exactly the point: open a wallet, stay active, and you might win a large share of a scheduled draw. What funds it is what makes it defensible: abandoned light — balances dormant ~5 years with no Will — recirculated under disclosed property rules instead of being lost forever like dead BTC. Nothing is minted; heirs always come first; you must already hold light to be eligible. Not financial advice; tax is the recipient’s problem.
Q08Do GPU operators see my chats?
Two tiers, honestly. Baseline: history is wallet-encrypted at rest, TLS in transit, nothing on a public chain, and operators are policy-bound (bonded, removable) not to log or resell — but on ordinary nodes, plaintext exists in GPU memory during the answer. Confidential tier (the goal, and the intended LuxGPT default): TEE nodes where content decrypts only inside attested secure hardware, so even the machine’s owner cannot read it. We label which tier a job runs on.
Q09Are you building your own blockchain?
Not as the launch goal. Lux is an AI protocol. Settlement starts as ledger credits and can use an existing public chain for deposits, payouts, and bonds. A custom L1 is a named hard cut — it would burn engineering on consensus instead of on AI quality.
Q10Is this Ethereum? Do I pay in ETH?
No. The product currency is light ($LXTH). If an ETH-family chain is used for settlement, gas is postage on that chain — a background cost, not the AI bill. “Buy AI with ETH” is not the story.
Q11How do operators get paid?
92% of every payment for an answer goes to the node that delivered it. Payment follows delivered work: fake advertised capacity earns nothing, failed jobs cost the user nothing, and proven fast nodes get first bursts of traffic. Stable payout rails are planned so operators can pay power bills without token-price roulette.
Q12What ships first?
Phase 0: a working demo — API, nodes, metering, early LuxGPT. V1: external nodes, wallet share/receivepay/earn, LuxGPT as the first dApp, OpenAI-compatible API. The lottery, bridges, and DeFi layers come after the network demonstrably works (V2).
Q13How does a network of GPUs beat my one local GPU?
Your local GPU runs one small model for you alone. The network runs larger open models than consumer hardware can hold, serves concurrent load, fans out multi-agent jobs across many nodes, and fails over when a machine dies. Local is great for private small jobs; Lux is for the capability tier above that — and node owners can serve the network with the same hardware when idle.
Q14Why would light have value later, with DeFi and LPs?
Sequence: the token has use first (every answer costs light; every node earns it). More dApps embedding AI increase demand. Bridges add demand from other chains. Only then do LPs and farming matter — liquidity around a token people actually need is valuable; liquidity around a token nobody uses is exit liquidity. We refuse to run that order backwards.
Q15What are you explicitly not claiming?
Not the first decentralized-AI idea ever. Not guaranteed parity with frontier closed labs. Not zkML at launch. Not “no node can ever see anything” on the ordinary tier. Not a new L1. Not yield promises, APY, or token price targets. The claim is narrower and real: a working decentralized AI pipe with a use-first token, a flagship dApp, and bridges out of hard-money dependency.
Appendix
Engineering depth, brand record, and boilerplate — collapsed so the main path stays readable.
A1Architecture for engineers
Actors
| Actor | Role |
|---|---|
| Users | LuxGPT / apps — pay light |
| Builders | Integrate the Lux API |
| Operators | Run Lux Node, receive light |
| Gateway / orchestrator | Routes jobs, meters, failover — semi-trusted at V1, progressive decentralization on a published ladder |
| Settlement | Balances, deposits, bonds, lottery/Will rules |
| Model registry | Digest-pinned model epochs (official versions) |
Request lifecycle
Effective capacity
R_i = EWMA( output AI tokens delivered / wall seconds )
scheduling weight = f(R_i, success rate, free slots, bond, recent strikes)Broadcast capacity is a hint. Fake broadcasts → timeouts → strikes → starvation. Honest fast nodes get first bursts.
On-chain vs off-chain
| On-chain / chain-anchored | Off-chain |
|---|---|
| Deposits and withdrawals · node registry and bonds · model epoch digests · fee parameters · settlement batch roots and payouts · slashes · Will roots and dormancy events | Prompts and completions · job queue and routing · heartbeats and live scores · weight blobs · streaming |
Model epochs & training
A model epoch is the official release: weights digest + tokenizer digest + config + runtime profile. Publish → nodes pull → flip active at a capacity threshold → drain the old epoch. The training treasury (4% pinch) funds eval-gated improvement on public or opt-in data only — never silent training on private chats. Not required for day-one ship.
Settlement path
| Phase | Mechanism |
|---|---|
| V1 | Credits — integer balances in a double-entry ledger; deposits by card or stablecoin; stable payout rails for operators |
| V1.5 | On-chain vault on an existing public chain, linked to the same account |
| V2 | Batch settlement roots, stake/slash, public $LXTH functions, Will + Sunrise rules on-chain |
A2Brand — proof of exploration
| Direction | Idea | Verdict |
|---|---|---|
| Neon cyber yellow | High-chroma yellow on dark; crypto-default energy | Reject |
| Pure monochrome | Academic black-on-white; no light identity | Reject alone |
| Daylight | Muted butter/cream, soft gold, charcoal ink | Selected |
| Dark-first | Operator-terminal aesthetic | Defer |
Rules: yellow is wash/mark/border, never body text. Type: Instrument Sans (UI) + Newsreader (long-form) + IBM Plex Mono (code/meters). Voice: clear and concrete; ethos lines only as short labeled pull-quotes. Logo: the connected lumen — overlapping discs + one thin arc. Full record in BRAND.md.
A3Docs standard
This litepaper is the canonical schematic — the why and the what-must-be-true. When engineering starts, a proper docs site (Mintlify/Docusaurus-class: sidebar, search, versioned API reference, operator runbooks) takes the how-to. Patterns adopted here from serious protocols: sticky contents, version badge, explicit non-claims, hard-questions surface, real disclaimer.
A4Build checklist
V1 outcomes — definition of shipped
- OpenAI-compatible
/v1/chat/completionswith streaming - At least one open model, digest-pinned
- Wallet ledger: share / receivepay / earn light + treasury pinch
- LuxGPT: wallet signup, welcome light, chat, metered billing
- Lux Node agent: heartbeat, job pull, receipt signing, failover
- Delivery-scored routing; probes; probation for new nodes
- Baseline privacy tier: encrypted history, no content on-chain
- Published fee split and non-claims
Later — must not block V1
- Will + Sunrise lottery live (5y dormancy, heirs, ~6-month draws)
- On-chain vault + batch settlement on an existing chain
- Bridges for foreign chains/dApps
- Confidential-compute (TEE) node tier as LuxGPT default
- Public $LXTH stake/slash; treasury training jobs
- Multi-agent fan-out across nodes
A5Glossary
- Lux Ethos
- The project; its name and character
- Lux
- The AI network / protocol
- light
- The unit of value; what you pay and earn
- $LXTH
- On-chain ticker for light
- LuxGPT
- First dApp: chat with a wallet, pay in light
- Lux Node
- Operator software; a GPU computer serving the network
- Lux API
- OpenAI-compatible builder surface
- Node
- A computer on the network with a GPU
- AI tokens
- Text pieces used to meter input/output size — not currency
- Bridge
- Move value from another chain to use Lux AI
- Settlement
- How payments and balances are recorded
- Model epoch
- Official AI model version everyone runs
- Will Protocol
- Name heirs for your light; heirs always come first
- Sunrise lottery
- Periodic prize draws that recirculate abandoned light to active wallets holding light
- Dormancy
- ~5 years of no activity; the timer resets on use, mining, sign-in, refresh, or Will update
- Welcome light
- Starter light for new wallets
A6Disclaimer
This litepaper is a technical and product design document for discussion and implementation guidance. It is not an offer of securities, not financial advice, and not a promise of token value or returns. Protocol participation is payment for compute and related network services. Sunrise draws are recirculation of abandoned balances under disclosed protocol property rules, not an investment product; tax treatment of any light received is the recipient’s own responsibility. Parameters (fee splits, dormancy timers, draw cadence) are illustrative defaults subject to change through a documented process.